/*!
 * protobuf.js v6.8.4 (c) 2016, daniel wirtz
 * compiled thu, 04 jan 2018 21:51:39 utc
 * licensed under the bsd-3-clause license
 * see: https://github.com/dcodeio/protobuf.js for details
 */
(function (global, undefined) {
    "use strict"; (function prelude(modules, cache, entries) {

        // This is the prelude used to bundle protobuf.js for the browser. Wraps up the CommonJS
        // sources through a conflict-free require shim and is again wrapped within an iife that
        // provides a unified `global` and a minification-friendly `undefined` var plus a global
        // "use strict" directive so that minification can remove the directives of each module.

        function $require(name) {
            var $module = cache[name];
            if (!$module)
                modules[name][0].call($module = cache[name] = { exports: {} }, $require, $module, $module.exports);
            return $module.exports;
        }

        // Expose globally
        var protobuf = global.protobuf = $require(entries[0]);

        // Be nice to AMD
        if (typeof define === "function" && define.amd)
            define(["long"], function (Long) {
                if (Long && Long.isLong) {
                    protobuf.util.Long = Long;
                    protobuf.configure();
                }
                return protobuf;
            });

        // Be nice to CommonJS
        if (typeof module === "object" && module && module.exports)
            module.exports = protobuf;

    })/* end of prelude */({
        1: [function (require, module, exports) {
            "use strict";
            module.exports = asPromise;

            /**
             * Callback as used by {@link util.asPromise}.
             * @typedef asPromiseCallback
             * @type {function}
             * @param {Error|null} error Error, if any
             * @param {...*} params Additional arguments
             * @returns {undefined}
             */

            /**
             * Returns a promise from a node-style callback function.
             * @memberof util
             * @param {asPromiseCallback} fn Function to call
             * @param {*} ctx Function context
             * @param {...*} params Function arguments
             * @returns {Promise<*>} Promisified function
             */
            function asPromise(fn, ctx/*, varargs */) {
                var params = new Array(arguments.length - 1),
                    offset = 0,
                    index = 2,
                    pending = true;
                while (index < arguments.length)
                    params[offset++] = arguments[index++];
                return new Promise(function executor(resolve, reject) {
                    params[offset] = function callback(err/*, varargs */) {
                        if (pending) {
                            pending = false;
                            if (err)
                                reject(err);
                            else {
                                var params = new Array(arguments.length - 1),
                                    offset = 0;
                                while (offset < params.length)
                                    params[offset++] = arguments[offset];
                                resolve.apply(null, params);
                            }
                        }
                    };
                    try {
                        fn.apply(ctx || null, params);
                    } catch (err) {
                        if (pending) {
                            pending = false;
                            reject(err);
                        }
                    }
                });
            }

        }, {}], 2: [function (require, module, exports) {
            "use strict";

            /**
             * A minimal base64 implementation for number arrays.
             * @memberof util
             * @namespace
             */
            var base64 = exports;

            /**
             * Calculates the byte length of a base64 encoded string.
             * @param {string} string Base64 encoded string
             * @returns {number} Byte length
             */
            base64.length = function length(string) {
                var p = string.length;
                if (!p)
                    return 0;
                var n = 0;
                while (--p % 4 > 1 && string.charAt(p) === "=")
                    ++n;
                return Math.ceil(string.length * 3) / 4 - n;
            };

            // Base64 encoding table
            var b64 = new Array(64);

            // Base64 decoding table
            var s64 = new Array(123);

            // 65..90, 97..122, 48..57, 43, 47
            for (var i = 0; i < 64;)
                s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;

            /**
             * Encodes a buffer to a base64 encoded string.
             * @param {Uint8Array} buffer Source buffer
             * @param {number} start Source start
             * @param {number} end Source end
             * @returns {string} Base64 encoded string
             */
            base64.encode = function encode(buffer, start, end) {
                var parts = null,
                    chunk = [];
                var i = 0, // output index
                    j = 0, // goto index
                    t;     // temporary
                while (start < end) {
                    var b = buffer[start++];
                    switch (j) {
                        case 0:
                            chunk[i++] = b64[b >> 2];
                            t = (b & 3) << 4;
                            j = 1;
                            break;
                        case 1:
                            chunk[i++] = b64[t | b >> 4];
                            t = (b & 15) << 2;
                            j = 2;
                            break;
                        case 2:
                            chunk[i++] = b64[t | b >> 6];
                            chunk[i++] = b64[b & 63];
                            j = 0;
                            break;
                    }
                    if (i > 8191) {
                        (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
                        i = 0;
                    }
                }
                if (j) {
                    chunk[i++] = b64[t];
                    chunk[i++] = 61;
                    if (j === 1)
                        chunk[i++] = 61;
                }
                if (parts) {
                    if (i)
                        parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
                    return parts.join("");
                }
                return String.fromCharCode.apply(String, chunk.slice(0, i));
            };

            var invalidEncoding = "invalid encoding";

            /**
             * Decodes a base64 encoded string to a buffer.
             * @param {string} string Source string
             * @param {Uint8Array} buffer Destination buffer
             * @param {number} offset Destination offset
             * @returns {number} Number of bytes written
             * @throws {Error} If encoding is invalid
             */
            base64.decode = function decode(string, buffer, offset) {
                var start = offset;
                var j = 0, // goto index
                    t;     // temporary
                for (var i = 0; i < string.length;) {
                    var c = string.charCodeAt(i++);
                    if (c === 61 && j > 1)
                        break;
                    if ((c = s64[c]) === undefined)
                        throw Error(invalidEncoding);
                    switch (j) {
                        case 0:
                            t = c;
                            j = 1;
                            break;
                        case 1:
                            buffer[offset++] = t << 2 | (c & 48) >> 4;
                            t = c;
                            j = 2;
                            break;
                        case 2:
                            buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
                            t = c;
                            j = 3;
                            break;
                        case 3:
                            buffer[offset++] = (t & 3) << 6 | c;
                            j = 0;
                            break;
                    }
                }
                if (j === 1)
                    throw Error(invalidEncoding);
                return offset - start;
            };

            /**
             * Tests if the specified string appears to be base64 encoded.
             * @param {string} string String to test
             * @returns {boolean} `true` if probably base64 encoded, otherwise false
             */
            base64.test = function test(string) {
                return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
            };

        }, {}], 3: [function (require, module, exports) {
            "use strict";
            module.exports = codegen;

            /**
             * Begins generating a function.
             * @memberof util
             * @param {string[]} functionParams Function parameter names
             * @param {string} [functionName] Function name if not anonymous
             * @returns {Codegen} Appender that appends code to the function's body
             */
            function codegen(functionParams, functionName) {

                /* istanbul ignore if */
                if (typeof functionParams === "string") {
                    functionName = functionParams;
                    functionParams = undefined;
                }

                var body = [];

                /**
                 * Appends code to the function's body or finishes generation.
                 * @typedef Codegen
                 * @type {function}
                 * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
                 * @param {...*} [formatParams] Format parameters
                 * @returns {Codegen|Function} Itself or the generated function if finished
                 * @throws {Error} If format parameter counts do not match
                 */

                function Codegen(formatStringOrScope) {
                    // note that explicit array handling below makes this ~50% faster

                    // finish the function
                    if (typeof formatStringOrScope !== "string") {
                        var source = toString();
                        if (codegen.verbose)
                            console.log("codegen: " + source); // eslint-disable-line no-console
                        source = "return " + source;
                        if (formatStringOrScope) {
                            var scopeKeys = Object.keys(formatStringOrScope),
                                scopeParams = new Array(scopeKeys.length + 1),
                                scopeValues = new Array(scopeKeys.length),
                                scopeOffset = 0;
                            while (scopeOffset < scopeKeys.length) {
                                scopeParams[scopeOffset] = scopeKeys[scopeOffset];
                                scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];
                            }
                            scopeParams[scopeOffset] = source;
                            return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func
                        }
                        return Function(source)(); // eslint-disable-line no-new-func
                    }

                    // otherwise append to body
                    var formatParams = new Array(arguments.length - 1),
                        formatOffset = 0;
                    while (formatOffset < formatParams.length)
                        formatParams[formatOffset] = arguments[++formatOffset];
                    formatOffset = 0;
                    formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
                        var value = formatParams[formatOffset++];
                        switch ($1) {
                            case "d": case "f": return String(Number(value));
                            case "i": return String(Math.floor(value));
                            case "j": return JSON.stringify(value);
                            case "s": return String(value);
                        }
                        return "%";
                    });
                    if (formatOffset !== formatParams.length)
                        throw Error("parameter count mismatch");
                    body.push(formatStringOrScope);
                    return Codegen;
                }

                function toString(functionNameOverride) {
                    return "function " + (functionNameOverride || functionName || "") + "(" + (functionParams && functionParams.join(",") || "") + "){\n  " + body.join("\n  ") + "\n}";
                }

                Codegen.toString = toString;
                return Codegen;
            }

            /**
             * Begins generating a function.
             * @memberof util
             * @function codegen
             * @param {string} [functionName] Function name if not anonymous
             * @returns {Codegen} Appender that appends code to the function's body
             * @variation 2
             */

            /**
             * When set to `true`, codegen will log generated code to console. Useful for debugging.
             * @name util.codegen.verbose
             * @type {boolean}
             */
            codegen.verbose = false;

        }, {}], 4: [function (require, module, exports) {
            "use strict";
            module.exports = EventEmitter;

            /**
             * Constructs a new event emitter instance.
             * @classdesc A minimal event emitter.
             * @memberof util
             * @constructor
             */
            function EventEmitter() {

                /**
                 * Registered listeners.
                 * @type {Object.<string,*>}
                 * @private
                 */
                this._listeners = {};
            }

            /**
             * Registers an event listener.
             * @param {string} evt Event name
             * @param {function} fn Listener
             * @param {*} [ctx] Listener context
             * @returns {util.EventEmitter} `this`
             */
            EventEmitter.prototype.on = function on(evt, fn, ctx) {
                (this._listeners[evt] || (this._listeners[evt] = [])).push({
                    fn: fn,
                    ctx: ctx || this
                });
                return this;
            };

            /**
             * Removes an event listener or any matching listeners if arguments are omitted.
             * @param {string} [evt] Event name. Removes all listeners if omitted.
             * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
             * @returns {util.EventEmitter} `this`
             */
            EventEmitter.prototype.off = function off(evt, fn) {
                if (evt === undefined)
                    this._listeners = {};
                else {
                    if (fn === undefined)
                        this._listeners[evt] = [];
                    else {
                        var listeners = this._listeners[evt];
                        for (var i = 0; i < listeners.length;)
                            if (listeners[i].fn === fn)
                                listeners.splice(i, 1);
                            else
                                ++i;
                    }
                }
                return this;
            };

            /**
             * Emits an event by calling its listeners with the specified arguments.
             * @param {string} evt Event name
             * @param {...*} args Arguments
             * @returns {util.EventEmitter} `this`
             */
            EventEmitter.prototype.emit = function emit(evt) {
                var listeners = this._listeners[evt];
                if (listeners) {
                    var args = [],
                        i = 1;
                    for (; i < arguments.length;)
                        args.push(arguments[i++]);
                    for (i = 0; i < listeners.length;)
                        listeners[i].fn.apply(listeners[i++].ctx, args);
                }
                return this;
            };

        }, {}], 5: [function (require, module, exports) {
            "use strict";
            module.exports = fetch;

            var asPromise = require(1),
                inquire = require(7);

            var fs = inquire("fs");

            /**
             * Node-style callback as used by {@link util.fetch}.
             * @typedef FetchCallback
             * @type {function}
             * @param {?Error} error Error, if any, otherwise `null`
             * @param {string} [contents] File contents, if there hasn't been an error
             * @returns {undefined}
             */

            /**
             * Options as used by {@link util.fetch}.
             * @typedef FetchOptions
             * @type {Object}
             * @property {boolean} [binary=false] Whether expecting a binary response
             * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest
             */

            /**
             * Fetches the contents of a file.
             * @memberof util
             * @param {string} filename File path or url
             * @param {FetchOptions} options Fetch options
             * @param {FetchCallback} callback Callback function
             * @returns {undefined}
             */
            function fetch(filename, options, callback) {
                if (typeof options === "function") {
                    callback = options;
                    options = {};
                } else if (!options)
                    options = {};

                if (!callback)
                    return asPromise(fetch, this, filename, options); // eslint-disable-line no-invalid-this

                // if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.
                if (!options.xhr && fs && fs.readFile)
                    return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
                        return err && typeof XMLHttpRequest !== "undefined"
                            ? fetch.xhr(filename, options, callback)
                            : err
                                ? callback(err)
                                : callback(null, options.binary ? contents : contents.toString("utf8"));
                    });

                // use the XHR version otherwise.
                return fetch.xhr(filename, options, callback);
            }

            /**
             * Fetches the contents of a file.
             * @name util.fetch
             * @function
             * @param {string} path File path or url
             * @param {FetchCallback} callback Callback function
             * @returns {undefined}
             * @variation 2
             */

            /**
             * Fetches the contents of a file.
             * @name util.fetch
             * @function
             * @param {string} path File path or url
             * @param {FetchOptions} [options] Fetch options
             * @returns {Promise<string|Uint8Array>} Promise
             * @variation 3
             */

            /**/
            fetch.xhr = function fetch_xhr(filename, options, callback) {
                var xhr = new XMLHttpRequest();
                xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {

                    if (xhr.readyState !== 4)
                        return undefined;

                    // local cors security errors return status 0 / empty string, too. afaik this cannot be
                    // reliably distinguished from an actually empty file for security reasons. feel free
                    // to send a pull request if you are aware of a solution.
                    if (xhr.status !== 0 && xhr.status !== 200)
                        return callback(Error("status " + xhr.status));

                    // if binary data is expected, make sure that some sort of array is returned, even if
                    // ArrayBuffers are not supported. the binary string fallback, however, is unsafe.
                    if (options.binary) {
                        var buffer = xhr.response;
                        if (!buffer) {
                            buffer = [];
                            for (var i = 0; i < xhr.responseText.length; ++i)
                                buffer.push(xhr.responseText.charCodeAt(i) & 255);
                        }
                        return callback(null, typeof Uint8Array !== "undefined" ? new Uint8Array(buffer) : buffer);
                    }
                    return callback(null, xhr.responseText);
                };

                if (options.binary) {
                    // ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers
                    if ("overrideMimeType" in xhr)
                        xhr.overrideMimeType("text/plain; charset=x-user-defined");
                    xhr.responseType = "arraybuffer";
                }

                xhr.open("GET", filename);
                xhr.send();
            };

        }, { "1": 1, "7": 7 }], 6: [function (require, module, exports) {
            "use strict";

            module.exports = factory(factory);

            /**
             * Reads / writes floats / doubles from / to buffers.
             * @name util.float
             * @namespace
             */

            /**
             * Writes a 32 bit float to a buffer using little endian byte order.
             * @name util.float.writeFloatLE
             * @function
             * @param {number} val Value to write
             * @param {Uint8Array} buf Target buffer
             * @param {number} pos Target buffer offset
             * @returns {undefined}
             */

            /**
             * Writes a 32 bit float to a buffer using big endian byte order.
             * @name util.float.writeFloatBE
             * @function
             * @param {number} val Value to write
             * @param {Uint8Array} buf Target buffer
             * @param {number} pos Target buffer offset
             * @returns {undefined}
             */

            /**
             * Reads a 32 bit float from a buffer using little endian byte order.
             * @name util.float.readFloatLE
             * @function
             * @param {Uint8Array} buf Source buffer
             * @param {number} pos Source buffer offset
             * @returns {number} Value read
             */

            /**
             * Reads a 32 bit float from a buffer using big endian byte order.
             * @name util.float.readFloatBE
             * @function
             * @param {Uint8Array} buf Source buffer
             * @param {number} pos Source buffer offset
             * @returns {number} Value read
             */

            /**
             * Writes a 64 bit double to a buffer using little endian byte order.
             * @name util.float.writeDoubleLE
             * @function
             * @param {number} val Value to write
             * @param {Uint8Array} buf Target buffer
             * @param {number} pos Target buffer offset
             * @returns {undefined}
             */

            /**
             * Writes a 64 bit double to a buffer using big endian byte order.
             * @name util.float.writeDoubleBE
             * @function
             * @param {number} val Value to write
             * @param {Uint8Array} buf Target buffer
             * @param {number} pos Target buffer offset
             * @returns {undefined}
             */

            /**
             * Reads a 64 bit double from a buffer using little endian byte order.
             * @name util.float.readDoubleLE
             * @function
             * @param {Uint8Array} buf Source buffer
             * @param {number} pos Source buffer offset
             * @returns {number} Value read
             */

            /**
             * Reads a 64 bit double from a buffer using big endian byte order.
             * @name util.float.readDoubleBE
             * @function
             * @param {Uint8Array} buf Source buffer
             * @param {number} pos Source buffer offset
             * @returns {number} Value read
             */

            // Factory function for the purpose of node-based testing in modified global environments
            function factory(exports) {

                // float: typed array
                if (typeof Float32Array !== "undefined") (function () {

                    var f32 = new Float32Array([-0]),
                        f8b = new Uint8Array(f32.buffer),
                        le = f8b[3] === 128;

                    function writeFloat_f32_cpy(val, buf, pos) {
                        f32[0] = val;
                        buf[pos] = f8b[0];
                        buf[pos + 1] = f8b[1];
                        buf[pos + 2] = f8b[2];
                        buf[pos + 3] = f8b[3];
                    }

                    function writeFloat_f32_rev(val, buf, pos) {
                        f32[0] = val;
                        buf[pos] = f8b[3];
                        buf[pos + 1] = f8b[2];
                        buf[pos + 2] = f8b[1];
                        buf[pos + 3] = f8b[0];
                    }

                    /* istanbul ignore next */
                    exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
                    /* istanbul ignore next */
                    exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;

                    function readFloat_f32_cpy(buf, pos) {
                        f8b[0] = buf[pos];
                        f8b[1] = buf[pos + 1];
                        f8b[2] = buf[pos + 2];
                        f8b[3] = buf[pos + 3];
                        return f32[0];
                    }

                    function readFloat_f32_rev(buf, pos) {
                        f8b[3] = buf[pos];
                        f8b[2] = buf[pos + 1];
                        f8b[1] = buf[pos + 2];
                        f8b[0] = buf[pos + 3];
                        return f32[0];
                    }

                    /* istanbul ignore next */
                    exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
                    /* istanbul ignore next */
                    exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;

                    // float: ieee754
                })(); else (function () {

                    function writeFloat_ieee754(writeUint, val, buf, pos) {
                        var sign = val < 0 ? 1 : 0;
                        if (sign)
                            val = -val;
                        if (val === 0)
                            writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
                        else if (isNaN(val))
                            writeUint(2143289344, buf, pos);
                        else if (val > 3.4028234663852886e+38) // +-Infinity
                            writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
                        else if (val < 1.1754943508222875e-38) // denormal
                            writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
                        else {
                            var exponent = Math.floor(Math.log(val) / Math.LN2),
                                mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
                            writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
                        }
                    }

                    exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
                    exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);

                    function readFloat_ieee754(readUint, buf, pos) {
                        var uint = readUint(buf, pos),
                            sign = (uint >> 31) * 2 + 1,
                            exponent = uint >>> 23 & 255,
                            mantissa = uint & 8388607;
                        return exponent === 255
                            ? mantissa
                                ? NaN
                                : sign * Infinity
                            : exponent === 0 // denormal
                                ? sign * 1.401298464324817e-45 * mantissa
                                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
                    }

                    exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
                    exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);

                })();

                // double: typed array
                if (typeof Float64Array !== "undefined") (function () {

                    var f64 = new Float64Array([-0]),
                        f8b = new Uint8Array(f64.buffer),
                        le = f8b[7] === 128;

                    function writeDouble_f64_cpy(val, buf, pos) {
                        f64[0] = val;
                        buf[pos] = f8b[0];
                        buf[pos + 1] = f8b[1];
                        buf[pos + 2] = f8b[2];
                        buf[pos + 3] = f8b[3];
                        buf[pos + 4] = f8b[4];
                        buf[pos + 5] = f8b[5];
                        buf[pos + 6] = f8b[6];
                        buf[pos + 7] = f8b[7];
                    }

                    function writeDouble_f64_rev(val, buf, pos) {
                        f64[0] = val;
                        buf[pos] = f8b[7];
                        buf[pos + 1] = f8b[6];
                        buf[pos + 2] = f8b[5];
                        buf[pos + 3] = f8b[4];
                        buf[pos + 4] = f8b[3];
                        buf[pos + 5] = f8b[2];
                        buf[pos + 6] = f8b[1];
                        buf[pos + 7] = f8b[0];
                    }

                    /* istanbul ignore next */
                    exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
                    /* istanbul ignore next */
                    exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;

                    function readDouble_f64_cpy(buf, pos) {
                        f8b[0] = buf[pos];
                        f8b[1] = buf[pos + 1];
                        f8b[2] = buf[pos + 2];
                        f8b[3] = buf[pos + 3];
                        f8b[4] = buf[pos + 4];
                        f8b[5] = buf[pos + 5];
                        f8b[6] = buf[pos + 6];
                        f8b[7] = buf[pos + 7];
                        return f64[0];
                    }

                    function readDouble_f64_rev(buf, pos) {
                        f8b[7] = buf[pos];
                        f8b[6] = buf[pos + 1];
                        f8b[5] = buf[pos + 2];
                        f8b[4] = buf[pos + 3];
                        f8b[3] = buf[pos + 4];
                        f8b[2] = buf[pos + 5];
                        f8b[1] = buf[pos + 6];
                        f8b[0] = buf[pos + 7];
                        return f64[0];
                    }

                    /* istanbul ignore next */
                    exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
                    /* istanbul ignore next */
                    exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;

                    // double: ieee754
                })(); else (function () {

                    function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
                        var sign = val < 0 ? 1 : 0;
                        if (sign)
                            val = -val;
                        if (val === 0) {
                            writeUint(0, buf, pos + off0);
                            writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
                        } else if (isNaN(val)) {
                            writeUint(0, buf, pos + off0);
                            writeUint(2146959360, buf, pos + off1);
                        } else if (val > 1.7976931348623157e+308) { // +-Infinity
                            writeUint(0, buf, pos + off0);
                            writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
                        } else {
                            var mantissa;
                            if (val < 2.2250738585072014e-308) { // denormal
                                mantissa = val / 5e-324;
                                writeUint(mantissa >>> 0, buf, pos + off0);
                                writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
                            } else {
                                var exponent = Math.floor(Math.log(val) / Math.LN2);
                                if (exponent === 1024)
                                    exponent = 1023;
                                mantissa = val * Math.pow(2, -exponent);
                                writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
                                writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
                            }
                        }
                    }

                    exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
                    exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);

                    function readDouble_ieee754(readUint, off0, off1, buf, pos) {
                        var lo = readUint(buf, pos + off0),
                            hi = readUint(buf, pos + off1);
                        var sign = (hi >> 31) * 2 + 1,
                            exponent = hi >>> 20 & 2047,
                            mantissa = 4294967296 * (hi & 1048575) + lo;
                        return exponent === 2047
                            ? mantissa
                                ? NaN
                                : sign * Infinity
                            : exponent === 0 // denormal
                                ? sign * 5e-324 * mantissa
                                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
                    }

                    exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
                    exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);

                })();

                return exports;
            }

            // uint helpers

            function writeUintLE(val, buf, pos) {
                buf[pos] = val & 255;
                buf[pos + 1] = val >>> 8 & 255;
                buf[pos + 2] = val >>> 16 & 255;
                buf[pos + 3] = val >>> 24;
            }

            function writeUintBE(val, buf, pos) {
                buf[pos] = val >>> 24;
                buf[pos + 1] = val >>> 16 & 255;
                buf[pos + 2] = val >>> 8 & 255;
                buf[pos + 3] = val & 255;
            }

            function readUintLE(buf, pos) {
                return (buf[pos]
                    | buf[pos + 1] << 8
                    | buf[pos + 2] << 16
                    | buf[pos + 3] << 24) >>> 0;
            }

            function readUintBE(buf, pos) {
                return (buf[pos] << 24
                    | buf[pos + 1] << 16
                    | buf[pos + 2] << 8
                    | buf[pos + 3]) >>> 0;
            }

        }, {}], 7: [function (require, module, exports) {
            "use strict";
            module.exports = inquire;

            /**
             * Requires a module only if available.
             * @memberof util
             * @param {string} moduleName Module to require
             * @returns {?Object} Required module if available and not empty, otherwise `null`
             */
            function inquire(moduleName) {
                try {
                    var mod = eval("quire".replace(/^/, "re"))(moduleName); // eslint-disable-line no-eval
                    if (mod && (mod.length || Object.keys(mod).length))
                        return mod;
                } catch (e) { } // eslint-disable-line no-empty
                return null;
            }

        }, {}], 8: [function (require, module, exports) {
            "use strict";

            /**
             * A minimal path module to resolve Unix, Windows and URL paths alike.
             * @memberof util
             * @namespace
             */
            var path = exports;

            var isAbsolute =
                /**
                 * Tests if the specified path is absolute.
                 * @param {string} path Path to test
                 * @returns {boolean} `true` if path is absolute
                 */
                path.isAbsolute = function isAbsolute(path) {
                    return /^(?:\/|\w+:)/.test(path);
                };

            var normalize =
                /**
                 * Normalizes the specified path.
                 * @param {string} path Path to normalize
                 * @returns {string} Normalized path
                 */
                path.normalize = function normalize(path) {
                    path = path.replace(/\\/g, "/")
                        .replace(/\/{2,}/g, "/");
                    var parts = path.split("/"),
                        absolute = isAbsolute(path),
                        prefix = "";
                    if (absolute)
                        prefix = parts.shift() + "/";
                    for (var i = 0; i < parts.length;) {
                        if (parts[i] === "..") {
                            if (i > 0 && parts[i - 1] !== "..")
                                parts.splice(--i, 2);
                            else if (absolute)
                                parts.splice(i, 1);
                            else
                                ++i;
                        } else if (parts[i] === ".")
                            parts.splice(i, 1);
                        else
                            ++i;
                    }
                    return prefix + parts.join("/");
                };

            /**
             * Resolves the specified include path against the specified origin path.
             * @param {string} originPath Path to the origin file
             * @param {string} includePath Include path relative to origin path
             * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
             * @returns {string} Path to the include file
             */
            path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
                if (!alreadyNormalized)
                    includePath = normalize(includePath);
                if (isAbsolute(includePath))
                    return includePath;
                if (!alreadyNormalized)
                    originPath = normalize(originPath);
                return (originPath = originPath.replace(/(?:\/|^)[^/]+$/, "")).length ? normalize(originPath + "/" + includePath) : includePath;
            };

        }, {}], 9: [function (require, module, exports) {
            "use strict";
            module.exports = pool;

            /**
             * An allocator as used by {@link util.pool}.
             * @typedef PoolAllocator
             * @type {function}
             * @param {number} size Buffer size
             * @returns {Uint8Array} Buffer
             */

            /**
             * A slicer as used by {@link util.pool}.
             * @typedef PoolSlicer
             * @type {function}
             * @param {number} start Start offset
             * @param {number} end End offset
             * @returns {Uint8Array} Buffer slice
             * @this {Uint8Array}
             */

            /**
             * A general purpose buffer pool.
             * @memberof util
             * @function
             * @param {PoolAllocator} alloc Allocator
             * @param {PoolSlicer} slice Slicer
             * @param {number} [size=8192] Slab size
             * @returns {PoolAllocator} Pooled allocator
             */
            function pool(alloc, slice, size) {
                var SIZE = size || 8192;
                var MAX = SIZE >>> 1;
                var slab = null;
                var offset = SIZE;
                return function pool_alloc(size) {
                    if (size < 1 || size > MAX)
                        return alloc(size);
                    if (offset + size > SIZE) {
                        slab = alloc(SIZE);
                        offset = 0;
                    }
                    var buf = slice.call(slab, offset, offset += size);
                    if (offset & 7) // align to 32 bit
                        offset = (offset | 7) + 1;
                    return buf;
                };
            }

        }, {}], 10: [function (require, module, exports) {
            "use strict";

            /**
             * A minimal UTF8 implementation for number arrays.
             * @memberof util
             * @namespace
             */
            var utf8 = exports;

            /**
             * Calculates the UTF8 byte length of a string.
             * @param {string} string String
             * @returns {number} Byte length
             */
            utf8.length = function utf8_length(string) {
                var len = 0,
                    c = 0;
                for (var i = 0; i < string.length; ++i) {
                    c = string.charCodeAt(i);
                    if (c < 128)
                        len += 1;
                    else if (c < 2048)
                        len += 2;
                    else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
                        ++i;
                        len += 4;
                    } else
                        len += 3;
                }
                return len;
            };

            /**
             * Reads UTF8 bytes as a string.
             * @param {Uint8Array} buffer Source buffer
             * @param {number} start Source start
             * @param {number} end Source end
             * @returns {string} String read
             */
            utf8.read = function utf8_read(buffer, start, end) {
                var len = end - start;
                if (len < 1)
                    return "";
                var parts = null,
                    chunk = [],
                    i = 0, // char offset
                    t;     // temporary
                while (start < end) {
                    t = buffer[start++];
                    if (t < 128)
                        chunk[i++] = t;
                    else if (t > 191 && t < 224)
                        chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
                    else if (t > 239 && t < 365) {
                        t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
                        chunk[i++] = 0xD800 + (t >> 10);
                        chunk[i++] = 0xDC00 + (t & 1023);
                    } else
                        chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
                    if (i > 8191) {
                        (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
                        i = 0;
                    }
                }
                if (parts) {
                    if (i)
                        parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
                    return parts.join("");
                }
                return String.fromCharCode.apply(String, chunk.slice(0, i));
            };

            /**
             * Writes a string as UTF8 bytes.
             * @param {string} string Source string
             * @param {Uint8Array} buffer Destination buffer
             * @param {number} offset Destination offset
             * @returns {number} Bytes written
             */
            utf8.write = function utf8_write(string, buffer, offset) {
                var start = offset,
                    c1, // character 1
                    c2; // character 2
                for (var i = 0; i < string.length; ++i) {
                    c1 = string.charCodeAt(i);
                    if (c1 < 128) {
                        buffer[offset++] = c1;
                    } else if (c1 < 2048) {
                        buffer[offset++] = c1 >> 6 | 192;
                        buffer[offset++] = c1 & 63 | 128;
                    } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
                        c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
                        ++i;
                        buffer[offset++] = c1 >> 18 | 240;
                        buffer[offset++] = c1 >> 12 & 63 | 128;
                        buffer[offset++] = c1 >> 6 & 63 | 128;
                        buffer[offset++] = c1 & 63 | 128;
                    } else {
                        buffer[offset++] = c1 >> 12 | 224;
                        buffer[offset++] = c1 >> 6 & 63 | 128;
                        buffer[offset++] = c1 & 63 | 128;
                    }
                }
                return offset - start;
            };

        }, {}], 11: [function (require, module, exports) {
            "use strict";
            module.exports = common;

            var commonRe = /\/|\./;

            /**
             * Provides common type definitions.
             * Can also be used to provide additional google types or your own custom types.
             * @param {string} name Short name as in `google/protobuf/[name].proto` or full file name
             * @param {Object.<string,*>} json JSON definition within `google.protobuf` if a short name, otherwise the file's root definition
             * @returns {undefined}
             * @property {INamespace} google/protobuf/any.proto Any
             * @property {INamespace} google/protobuf/duration.proto Duration
             * @property {INamespace} google/protobuf/empty.proto Empty
             * @property {INamespace} google/protobuf/struct.proto Struct, Value, NullValue and ListValue
             * @property {INamespace} google/protobuf/timestamp.proto Timestamp
             * @property {INamespace} google/protobuf/wrappers.proto Wrappers
             * @example
             * // manually provides descriptor.proto (assumes google/protobuf/ namespace and .proto extension)
             * protobuf.common("descriptor", descriptorJson);
             *
             * // manually provides a custom definition (uses my.foo namespace)
             * protobuf.common("my/foo/bar.proto", myFooBarJson);
             */
            function common(name, json) {
                if (!commonRe.test(name)) {
                    name = "google/protobuf/" + name + ".proto";
                    json = { nested: { google: { nested: { protobuf: { nested: json } } } } };
                }
                common[name] = json;
            }

            // Not provided because of limited use (feel free to discuss or to provide yourself):
            //
            // google/protobuf/descriptor.proto
            // google/protobuf/field_mask.proto
            // google/protobuf/source_context.proto
            // google/protobuf/type.proto
            //
            // Stripped and pre-parsed versions of these non-bundled files are instead available as part of
            // the repository or package within the google/protobuf directory.

            common("any", {

                /**
                 * Properties of a google.protobuf.Any message.
                 * @interface IAny
                 * @type {Object}
                 * @property {string} [typeUrl]
                 * @property {Uint8Array} [bytes]
                 * @memberof common
                 */
                Any: {
                    fields: {
                        type_url: {
                            type: "string",
                            id: 1
                        },
                        value: {
                            type: "bytes",
                            id: 2
                        }
                    }
                }
            });

            var timeType;

            common("duration", {

                /**
                 * Properties of a google.protobuf.Duration message.
                 * @interface IDuration
                 * @type {Object}
                 * @property {number|Long} [seconds]
                 * @property {number} [nanos]
                 * @memberof common
                 */
                Duration: timeType = {
                    fields: {
                        seconds: {
                            type: "int64",
                            id: 1
                        },
                        nanos: {
                            type: "int32",
                            id: 2
                        }
                    }
                }
            });

            common("timestamp", {

                /**
                 * Properties of a google.protobuf.Timestamp message.
                 * @interface ITimestamp
                 * @type {Object}
                 * @property {number|Long} [seconds]
                 * @property {number} [nanos]
                 * @memberof common
                 */
                Timestamp: timeType
            });

            common("empty", {

                /**
                 * Properties of a google.protobuf.Empty message.
                 * @interface IEmpty
                 * @memberof common
                 */
                Empty: {
                    fields: {}
                }
            });

            common("struct", {

                /**
                 * Properties of a google.protobuf.Struct message.
                 * @interface IStruct
                 * @type {Object}
                 * @property {Object.<string,IValue>} [fields]
                 * @memberof common
                 */
                Struct: {
                    fields: {
                        fields: {
                            keyType: "string",
                            type: "Value",
                            id: 1
                        }
                    }
                },

                /**
                 * Properties of a google.protobuf.Value message.
                 * @interface IValue
                 * @type {Object}
                 * @property {string} [kind]
                 * @property {0} [nullValue]
                 * @property {number} [numberValue]
                 * @property {string} [stringValue]
                 * @property {boolean} [boolValue]
                 * @property {IStruct} [structValue]
                 * @property {IListValue} [listValue]
                 * @memberof common
                 */
                Value: {
                    oneofs: {
                        kind: {
                            oneof: [
                                "nullValue",
                                "numberValue",
                                "stringValue",
                                "boolValue",
                                "structValue",
                                "listValue"
                            ]
                        }
                    },
                    fields: {
                        nullValue: {
                            type: "NullValue",
                            id: 1
                        },
                        numberValue: {
                            type: "double",
                            id: 2
                        },
                        stringValue: {
                            type: "string",
                            id: 3
                        },
                        boolValue: {
                            type: "bool",
                            id: 4
                        },
                        structValue: {
                            type: "Struct",
                            id: 5
                        },
                        listValue: {
                            type: "ListValue",
                            id: 6
                        }
                    }
                },

                NullValue: {
                    values: {
                        NULL_VALUE: 0
                    }
                },

                /**
                 * Properties of a google.protobuf.ListValue message.
                 * @interface IListValue
                 * @type {Object}
                 * @property {Array.<IValue>} [values]
                 * @memberof common
                 */
                ListValue: {
                    fields: {
                        values: {
                            rule: "repeated",
                            type: "Value",
                            id: 1
                        }
                    }
                }
            });

            common("wrappers", {

                /**
                 * Properties of a google.protobuf.DoubleValue message.
                 * @interface IDoubleValue
                 * @type {Object}
                 * @property {number} [value]
                 * @memberof common
                 */
                DoubleValue: {
                    fields: {
                        value: {
                            type: "double",
                            id: 1
                        }
                    }
                },

                /**
                 * Properties of a google.protobuf.FloatValue message.
                 * @interface IFloatValue
                 * @type {Object}
                 * @property {number} [value]
                 * @memberof common
                 */
                FloatValue: {
                    fields: {
                        value: {
                            type: "float",
                            id: 1
                        }
                    }
                },

                /**
                 * Properties of a google.protobuf.Int64Value message.
                 * @interface IInt64Value
                 * @type {Object}
                 * @property {number|Long} [value]
                 * @memberof common
                 */
                Int64Value: {
                    fields: {
                        value: {
                            type: "int64",
                            id: 1
                        }
                    }
                },

                /**
                 * Properties of a google.protobuf.UInt64Value message.
                 * @interface IUInt64Value
                 * @type {Object}
                 * @property {number|Long} [value]
                 * @memberof common
                 */
                UInt64Value: {
                    fields: {
                        value: {
                            type: "uint64",
                            id: 1
                        }
                    }
                },

                /**
                 * Properties of a google.protobuf.Int32Value message.
                 * @interface IInt32Value
                 * @type {Object}
                 * @property {number} [value]
                 * @memberof common
                 */
                Int32Value: {
                    fields: {
                        value: {
                            type: "int32",
                            id: 1
                        }
                    }
                },

                /**
                 * Properties of a google.protobuf.UInt32Value message.
                 * @interface IUInt32Value
                 * @type {Object}
                 * @property {number} [value]
                 * @memberof common
                 */
                UInt32Value: {
                    fields: {
                        value: {
                            type: "uint32",
                            id: 1
                        }
                    }
                },

                /**
                 * Properties of a google.protobuf.BoolValue message.
                 * @interface IBoolValue
                 * @type {Object}
                 * @property {boolean} [value]
                 * @memberof common
                 */
                BoolValue: {
                    fields: {
                        value: {
                            type: "bool",
                            id: 1
                        }
                    }
                },

                /**
                 * Properties of a google.protobuf.StringValue message.
                 * @interface IStringValue
                 * @type {Object}
                 * @property {string} [value]
                 * @memberof common
                 */
                StringValue: {
                    fields: {
                        value: {
                            type: "string",
                            id: 1
                        }
                    }
                },

                /**
                 * Properties of a google.protobuf.BytesValue message.
                 * @interface IBytesValue
                 * @type {Object}
                 * @property {Uint8Array} [value]
                 * @memberof common
                 */
                BytesValue: {
                    fields: {
                        value: {
                            type: "bytes",
                            id: 1
                        }
                    }
                }
            });

            /**
             * Gets the root definition of the specified common proto file.
             *
             * Bundled definitions are:
             * - google/protobuf/any.proto
             * - google/protobuf/duration.proto
             * - google/protobuf/empty.proto
             * - google/protobuf/struct.proto
             * - google/protobuf/timestamp.proto
             * - google/protobuf/wrappers.proto
             *
             * @param {string} file Proto file name
             * @returns {INamespace|null} Root definition or `null` if not defined
             */
            common.get = function get(file) {
                return common[file] || null;
            };

        }, {}], 12: [function (require, module, exports) {
            "use strict";
            /**
             * Runtime message from/to plain object converters.
             * @namespace
             */
            var converter = exports;

            var Enum = require(15),
                util = require(37);

            /**
             * Generates a partial value fromObject conveter.
             * @param {Codegen} gen Codegen instance
             * @param {Field} field Reflected field
             * @param {number} fieldIndex Field index
             * @param {string} prop Property reference
             * @returns {Codegen} Codegen instance
             * @ignore
             */
            function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
                /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
                if (field.resolvedType) {
                    if (field.resolvedType instanceof Enum) {
                        gen
                            ("switch(d%s){", prop);
                        for (var values = field.resolvedType.values, keys = Object.keys(values), i = 0; i < keys.length; ++i) {
                            if (field.repeated && values[keys[i]] === field.typeDefault) gen
                                ("default:");
                            gen
                                ("case%j:", keys[i])
                                ("case %i:", values[keys[i]])
                                ("m%s=%j", prop, values[keys[i]])
                                ("break");
                        } gen
                            ("}");
                    } else gen
                        ("if(typeof d%s!==\"object\")", prop)
                        ("throw TypeError(%j)", field.fullName + ": object expected")
                        ("m%s=types[%i].fromObject(d%s)", prop, fieldIndex, prop);
                } else {
                    var isUnsigned = false;
                    switch (field.type) {
                        case "double":
                        case "float": gen
                            ("m%s=Number(d%s)", prop, prop); // also catches "NaN", "Infinity"
                            break;
                        case "uint32":
                        case "fixed32": gen
                            ("m%s=d%s>>>0", prop, prop);
                            break;
                        case "int32":
                        case "sint32":
                        case "sfixed32": gen
                            ("m%s=d%s|0", prop, prop);
                            break;
                        case "uint64":
                            isUnsigned = true;
                        // eslint-disable-line no-fallthrough
                        case "int64":
                        case "sint64":
                        case "fixed64":
                        case "sfixed64": gen
                            ("if(util.Long)")
                            ("(m%s=util.Long.fromValue(d%s)).unsigned=%j", prop, prop, isUnsigned)
                            ("else if(typeof d%s===\"string\")", prop)
                            ("m%s=parseInt(d%s,10)", prop, prop)
                            ("else if(typeof d%s===\"number\")", prop)
                            ("m%s=d%s", prop, prop)
                            ("else if(typeof d%s===\"object\")", prop)
                            ("m%s=new util.LongBits(d%s.low>>>0,d%s.high>>>0).toNumber(%s)", prop, prop, prop, isUnsigned ? "true" : "");
                            break;
                        case "bytes": gen
                            ("if(typeof d%s===\"string\")", prop)
                            ("util.base64.decode(d%s,m%s=util.newBuffer(util.base64.length(d%s)),0)", prop, prop, prop)
                            ("else if(d%s.length)", prop)
                            ("m%s=d%s", prop, prop);
                            break;
                        case "string": gen
                            ("m%s=String(d%s)", prop, prop);
                            break;
                        case "bool": gen
                            ("m%s=Boolean(d%s)", prop, prop);
                            break;
                        /* default: gen
                            ("m%s=d%s", prop, prop);
                            break; */
                    }
                }
                return gen;
                /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
            }

            /**
             * Generates a plain object to runtime message converter specific to the specified message type.
             * @param {Type} mtype Message type
             * @returns {Codegen} Codegen instance
             */
            converter.fromObject = function fromObject(mtype) {
                /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
                var fields = mtype.fieldsArray;
                var gen = util.codegen(["d"], mtype.name + "$fromObject")
                    ("if(d instanceof this.ctor)")
                    ("return d");
                if (!fields.length) return gen
                    ("return new this.ctor");
                gen
                    ("var m=new this.ctor");
                for (var i = 0; i < fields.length; ++i) {
                    var field = fields[i].resolve(),
                        prop = util.safeProp(field.name);

                    // Map fields
                    if (field.map) {
                        gen
                            ("if(d%s){", prop)
                        ("if(typeof d%s!==\"object\")", prop)
                        ("throw TypeError(%j)", field.fullName + ": object expected")
                        ("m%s={}", prop)
                        ("for(var ks=Object.keys(d%s),i=0;i<ks.length;++i){", prop);
                        genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[ks[i]]")
                            ("}")
                            ("}");

                        // Repeated fields
                    } else if (field.repeated) {
                        gen
                            ("if(d%s){", prop)
                        ("if(!Array.isArray(d%s))", prop)
                        ("throw TypeError(%j)", field.fullName + ": array expected")
                        ("m%s=[]", prop)
                        ("for(var i=0;i<d%s.length;++i){", prop);
                        genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[i]")
                            ("}")
                            ("}");

                        // Non-repeated fields
                    } else {
                        if (!(field.resolvedType instanceof Enum)) gen // no need to test for null/undefined if an enum (uses switch)
                            ("if(d%s!=null){", prop); // !== undefined && !== null
                        genValuePartial_fromObject(gen, field, /* not sorted */ i, prop);
                        if (!(field.resolvedType instanceof Enum)) gen
                            ("}");
                    }
                } return gen
                    ("return m");
                /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
            };

            /**
             * Generates a partial value toObject converter.
             * @param {Codegen} gen Codegen instance
             * @param {Field} field Reflected field
             * @param {number} fieldIndex Field index
             * @param {string} prop Property reference
             * @returns {Codegen} Codegen instance
             * @ignore
             */
            function genValuePartial_toObject(gen, field, fieldIndex, prop) {
                /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
                if (field.resolvedType) {
                    if (field.resolvedType instanceof Enum) gen
                        ("d%s=o.enums===String?types[%i].values[m%s]:m%s", prop, fieldIndex, prop, prop);
                    else gen
                        ("d%s=types[%i].toObject(m%s,o)", prop, fieldIndex, prop);
                } else {
                    var isUnsigned = false;
                    switch (field.type) {
                        case "double":
                        case "float": gen
                            ("d%s=o.json&&!isFinite(m%s)?String(m%s):m%s", prop, prop, prop, prop);
                            break;
                        case "uint64":
                            isUnsigned = true;
                        // eslint-disable-line no-fallthrough
                        case "int64":
                        case "sint64":
                        case "fixed64":
                        case "sfixed64": gen
                            ("if(typeof m%s===\"number\")", prop)
                            ("d%s=o.longs===String?String(m%s):m%s", prop, prop, prop)
                            ("else") // Long-like
                            ("d%s=o.longs===String?util.Long.prototype.toString.call(m%s):o.longs===Number?new util.LongBits(m%s.low>>>0,m%s.high>>>0).toNumber(%s):m%s", prop, prop, prop, prop, isUnsigned ? "true" : "", prop);
                            break;
                        case "bytes": gen
                            ("d%s=o.bytes===String?util.base64.encode(m%s,0,m%s.length):o.bytes===Array?Array.prototype.slice.call(m%s):m%s", prop, prop, prop, prop, prop);
                            break;
                        default: gen
                            ("d%s=m%s", prop, prop);
                            break;
                    }
                }
                return gen;
                /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
            }

            /**
             * Generates a runtime message to plain object converter specific to the specified message type.
             * @param {Type} mtype Message type
             * @returns {Codegen} Codegen instance
             */
            converter.toObject = function toObject(mtype) {
                /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
                var fields = mtype.fieldsArray.slice().sort(util.compareFieldsById);
                if (!fields.length)
                    return util.codegen()("return {}");
                var gen = util.codegen(["m", "o"], mtype.name + "$toObject")
                    ("if(!o)")
                    ("o={}")
                    ("var d={}");

                var repeatedFields = [],
                    mapFields = [],
                    normalFields = [],
                    i = 0;
                for (; i < fields.length; ++i)
                    if (!fields[i].partOf)
                        (fields[i].resolve().repeated ? repeatedFields
                            : fields[i].map ? mapFields
                                : normalFields).push(fields[i]);

                if (repeatedFields.length) {
                    gen
                        ("if(o.arrays||o.defaults){");
                    for (i = 0; i < repeatedFields.length; ++i) gen
                        ("d%s=[]", util.safeProp(repeatedFields[i].name));
                    gen
                        ("}");
                }

                if (mapFields.length) {
                    gen
                        ("if(o.objects||o.defaults){");
                    for (i = 0; i < mapFields.length; ++i) gen
                        ("d%s={}", util.safeProp(mapFields[i].name));
                    gen
                        ("}");
                }

                if (normalFields.length) {
                    gen
                        ("if(o.defaults){");
                    for (i = 0; i < normalFields.length; ++i) {
                        var field = normalFields[i],
                            prop = util.safeProp(field.name);
                        if (field.resolvedType instanceof Enum) gen
                            ("d%s=o.enums===String?%j:%j", prop, field.resolvedType.valuesById[field.typeDefault], field.typeDefault);
                        else if (field.long) gen
                            ("if(util.Long){")
                            ("var n=new util.Long(%i,%i,%j)", field.typeDefault.low, field.typeDefault.high, field.typeDefault.unsigned)
                            ("d%s=o.longs===String?n.toString():o.longs===Number?n.toNumber():n", prop)
                            ("}else")
                            ("d%s=o.longs===String?%j:%i", prop, field.typeDefault.toString(), field.typeDefault.toNumber());
                        else if (field.bytes) gen
                            ("d%s=o.bytes===String?%j:%s", prop, String.fromCharCode.apply(String, field.typeDefault), "[" + Array.prototype.slice.call(field.typeDefault).join(",") + "]");
                        else gen
                            ("d%s=%j", prop, field.typeDefault); // also messages (=null)
                    } gen
                        ("}");
                }
                var hasKs2 = false;
                for (i = 0; i < fields.length; ++i) {
                    var field = fields[i],
                        index = mtype._fieldsArray.indexOf(field),
                        prop = util.safeProp(field.name);
                    if (field.map) {
                        if (!hasKs2) {
                            hasKs2 = true; gen
                                ("var ks2");
                        } gen
                            ("if(m%s&&(ks2=Object.keys(m%s)).length){", prop, prop)
                            ("d%s={}", prop)
                            ("for(var j=0;j<ks2.length;++j){");
                        genValuePartial_toObject(gen, field, /* sorted */ index, prop + "[ks2[j]]")
                            ("}");
                    } else if (field.repeated) {
                        gen
                            ("if(m%s&&m%s.length){", prop, prop)
                        ("d%s=[]", prop)
                        ("for(var j=0;j<m%s.length;++j){", prop);
                        genValuePartial_toObject(gen, field, /* sorted */ index, prop + "[j]")
                            ("}");
                    } else {
                        gen
                            ("if(m%s!=null&&m.hasOwnProperty(%j)){", prop, field.name); // !== undefined && !== null
                        genValuePartial_toObject(gen, field, /* sorted */ index, prop);
                        if (field.partOf) gen
                            ("if(o.oneofs)")
                            ("d%s=%j", util.safeProp(field.partOf.name), field.name);
                    }
                    gen
                        ("}");
                }
                return gen
                    ("return d");
                /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
            };

        }, { "15": 15, "37": 37 }], 13: [function (require, module, exports) {
            "use strict";
            module.exports = decoder;

            var Enum = require(15),
                types = require(36),
                util = require(37);

            function missing(field) {
                return "missing required '" + field.name + "'";
            }

            /**
             * Generates a decoder specific to the specified message type.
             * @param {Type} mtype Message type
             * @returns {Codegen} Codegen instance
             */
            function decoder(mtype) {
                /* eslint-disable no-unexpected-multiline */
                var gen = util.codegen(["r", "l"], mtype.name + "$decode")
                    ("if(!(r instanceof Reader))")
                    ("r=Reader.create(r)")
                    ("var c=l===undefined?r.len:r.pos+l,m=new this.ctor" + (mtype.fieldsArray.filter(function (field) { return field.map; }).length ? ",k" : ""))
                    ("while(r.pos<c){")
                    ("var t=r.uint32()");
                if (mtype.group) gen
                    ("if((t&7)===4)")
                    ("break");
                gen
                    ("switch(t>>>3){");

                var i = 0;
                for (; i < /* initializes */ mtype.fieldsArray.length; ++i) {
                    var field = mtype._fieldsArray[i].resolve(),
                        type = field.resolvedType instanceof Enum ? "int32" : field.type,
                        ref = "m" + util.safeProp(field.name); gen
                            ("case %i:", field.id);

                    // Map fields
                    if (field.map) {
                        gen
                            ("r.skip().pos++") // assumes id 1 + key wireType
                        ("if(%s===util.emptyObject)", ref)
                        ("%s={}", ref)
                        ("k=r.%s()", field.keyType)
                        ("r.pos++"); // assumes id 2 + value wireType
                        if (types.long[field.keyType] !== undefined) {
                            if (types.basic[type] === undefined) gen
                                ("%s[typeof k===\"object\"?util.longToHash(k):k]=types[%i].decode(r,r.uint32())", ref, i); // can't be groups
                            else gen
                                ("%s[typeof k===\"object\"?util.longToHash(k):k]=r.%s()", ref, type);
                        } else {
                            if (types.basic[type] === undefined) gen
                                ("%s[k]=types[%i].decode(r,r.uint32())", ref, i); // can't be groups
                            else gen
                                ("%s[k]=r.%s()", ref, type);
                        }

                        // Repeated fields
                    } else if (field.repeated) {
                        gen

                            ("if(!(%s&&%s.length))", ref, ref)
                        ("%s=[]", ref);

                        // Packable (always check for forward and backward compatiblity)
                        if (types.packed[type] !== undefined) gen
                            ("if((t&7)===2){")
                            ("var c2=r.uint32()+r.pos")
                            ("while(r.pos<c2)")
                            ("%s.push(r.%s())", ref, type)
                            ("}else");

                        // Non-packed
                        if (types.basic[type] === undefined) gen(field.resolvedType.group
                            ? "%s.push(types[%i].decode(r))"
                            : "%s.push(types[%i].decode(r,r.uint32()))", ref, i);
                        else gen
                            ("%s.push(r.%s())", ref, type);

                        // Non-repeated
                    } else if (types.basic[type] === undefined) gen(field.resolvedType.group
                        ? "%s=types[%i].decode(r)"
                        : "%s=types[%i].decode(r,r.uint32())", ref, i);
                    else gen
                        ("%s=r.%s()", ref, type);
                    gen
                        ("break");
                    // Unknown fields
                } gen
                    ("default:")
                    ("r.skipType(t&7)")
                    ("break")

                    ("}")
                    ("}");

                // Field presence
                for (i = 0; i < mtype._fieldsArray.length; ++i) {
                    var rfield = mtype._fieldsArray[i];
                    if (rfield.required) gen
                        ("if(!m.hasOwnProperty(%j))", rfield.name)
                        ("throw util.ProtocolError(%j,{instance:m})", missing(rfield));
                }

                return gen
                    ("return m");
                /* eslint-enable no-unexpected-multiline */
            }

        }, { "15": 15, "36": 36, "37": 37 }], 14: [function (require, module, exports) {
            "use strict";
            module.exports = encoder;

            var Enum = require(15),
                types = require(36),
                util = require(37);

            /**
             * Generates a partial message type encoder.
             * @param {Codegen} gen Codegen instance
             * @param {Field} field Reflected field
             * @param {number} fieldIndex Field index
             * @param {string} ref Variable reference
             * @returns {Codegen} Codegen instance
             * @ignore
             */
            function genTypePartial(gen, field, fieldIndex, ref) {
                return field.resolvedType.group
                    ? gen("types[%i].encode(%s,w.uint32(%i)).uint32(%i)", fieldIndex, ref, (field.id << 3 | 3) >>> 0, (field.id << 3 | 4) >>> 0)
                    : gen("types[%i].encode(%s,w.uint32(%i).fork()).ldelim()", fieldIndex, ref, (field.id << 3 | 2) >>> 0);
            }

            /**
             * Generates an encoder specific to the specified message type.
             * @param {Type} mtype Message type
             * @returns {Codegen} Codegen instance
             */
            function encoder(mtype) {
                /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
                var gen = util.codegen(["m", "w"], mtype.name + "$encode")
                    ("if(!w)")
                    ("w=Writer.create()");

                var i, ref;

                // "when a message is serialized its known fields should be written sequentially by field number"
                var fields = /* initializes */ mtype.fieldsArray.slice().sort(util.compareFieldsById);

                for (var i = 0; i < fields.length; ++i) {
                    var field = fields[i].resolve(),
                        index = mtype._fieldsArray.indexOf(field),
                        type = field.resolvedType instanceof Enum ? "int32" : field.type,
                        wireType = types.basic[type];
                    ref = "m" + util.safeProp(field.name);

                    // Map fields
                    if (field.map) {
                        gen
                            ("if(%s!=null&&m.hasOwnProperty(%j)){", ref, field.name) // !== undefined && !== null
                            ("for(var ks=Object.keys(%s),i=0;i<ks.length;++i){", ref)
                            ("w.uint32(%i).fork().uint32(%i).%s(ks[i])", (field.id << 3 | 2) >>> 0, 8 | types.mapKey[field.keyType], field.keyType);
                        if (wireType === undefined) gen
                            ("types[%i].encode(%s[ks[i]],w.uint32(18).fork()).ldelim().ldelim()", index, ref); // can't be groups
                        else gen
                            (".uint32(%i).%s(%s[ks[i]]).ldelim()", 16 | wireType, type, ref);
                        gen
                            ("}")
                            ("}");

                        // Repeated fields
                    } else if (field.repeated) {
                        gen
                            ("if(%s!=null&&%s.length){", ref, ref); // !== undefined && !== null

                        // Packed repeated
                        if (field.packed && types.packed[type] !== undefined) {
                            gen

                                ("w.uint32(%i).fork()", (field.id << 3 | 2) >>> 0)
                            ("for(var i=0;i<%s.length;++i)", ref)
                            ("w.%s(%s[i])", type, ref)
                            ("w.ldelim()");

                            // Non-packed
                        } else {
                            gen

                                ("for(var i=0;i<%s.length;++i)", ref);
                            if (wireType === undefined)
                                genTypePartial(gen, field, index, ref + "[i]");
                            else gen
                                ("w.uint32(%i).%s(%s[i])", (field.id << 3 | wireType) >>> 0, type, ref);

                        } gen
                            ("}");

                        // Non-repeated
                    } else {
                        if (field.optional) gen
                            ("if(%s!=null&&m.hasOwnProperty(%j))", ref, field.name); // !== undefined && !== null

                        if (wireType === undefined)
                            genTypePartial(gen, field, index, ref);
                        else gen
                            ("w.uint32(%i).%s(%s)", (field.id << 3 | wireType) >>> 0, type, ref);

                    }
                }

                return gen
                    ("return w");
                /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
            }
        }, { "15": 15, "36": 36, "37": 37 }], 15: [function (require, module, exports) {
            "use strict";
            module.exports = Enum;

            // extends ReflectionObject
            var ReflectionObject = require(24);
            ((Enum.prototype = Object.create(ReflectionObject.prototype)).constructor = Enum).className = "Enum";

            var Namespace = require(23),
                util = require(37);

            /**
             * Constructs a new enum instance.
             * @classdesc Reflected enum.
             * @extends ReflectionObject
             * @constructor
             * @param {string} name Unique name within its namespace
             * @param {Object.<string,number>} [values] Enum values as an object, by name
             * @param {Object.<string,*>} [options] Declared options
             */
            function Enum(name, values, options) {
                ReflectionObject.call(this, name, options);

                if (values && typeof values !== "object")
                    throw TypeError("values must be an object");

                /**
                 * Enum values by id.
                 * @type {Object.<number,string>}
                 */
                this.valuesById = {};

                /**
                 * Enum values by name.
                 * @type {Object.<string,number>}
                 */
                this.values = Object.create(this.valuesById); // toJSON, marker

                /**
                 * Value comment texts, if any.
                 * @type {Object.<string,string>}
                 */
                this.comments = {};

                /**
                 * Reserved ranges, if any.
                 * @type {Array.<number[]|string>}
                 */
                this.reserved = undefined; // toJSON

                // Note that values inherit valuesById on their prototype which makes them a TypeScript-
                // compatible enum. This is used by pbts to write actual enum definitions that work for
                // static and reflection code alike instead of emitting generic object definitions.

                if (values)
                    for (var keys = Object.keys(values), i = 0; i < keys.length; ++i)
                        if (typeof values[keys[i]] === "number") // use forward entries only
                            this.valuesById[this.values[keys[i]] = values[keys[i]]] = keys[i];
            }

            /**
             * Enum descriptor.
             * @interface IEnum
             * @property {Object.<string,number>} values Enum values
             * @property {Object.<string,*>} [options] Enum options
             */

            /**
             * Constructs an enum from an enum descriptor.
             * @param {string} name Enum name
             * @param {IEnum} json Enum descriptor
             * @returns {Enum} Created enum
             * @throws {TypeError} If arguments are invalid
             */
            Enum.fromJSON = function fromJSON(name, json) {
                var enm = new Enum(name, json.values, json.options);
                enm.reserved = json.reserved;
                return enm;
            };

            /**
             * Converts this enum to an enum descriptor.
             * @returns {IEnum} Enum descriptor
             */
            Enum.prototype.toJSON = function toJSON() {
                return util.toObject([
                    "options", this.options,
                    "values", this.values,
                    "reserved", this.reserved && this.reserved.length ? this.reserved : undefined
                ]);
            };

            /**
             * Adds a value to this enum.
             * @param {string} name Value name
             * @param {number} id Value id
             * @param {string} [comment] Comment, if any
             * @returns {Enum} `this`
             * @throws {TypeError} If arguments are invalid
             * @throws {Error} If there is already a value with this name or id
             */
            Enum.prototype.add = function add(name, id, comment) {
                // utilized by the parser but not by .fromJSON

                if (!util.isString(name))
                    throw TypeError("name must be a string");

                if (!util.isInteger(id))
                    throw TypeError("id must be an integer");

                if (this.values[name] !== undefined)
                    throw Error("duplicate name '" + name + "' in " + this);

                if (this.isReservedId(id))
                    throw Error("id " + id + " is reserved in " + this);

                if (this.isReservedName(name))
                    throw Error("name '" + name + "' is reserved in " + this);

                if (this.valuesById[id] !== undefined) {
                    if (!(this.options && this.options.allow_alias))
                        throw Error("duplicate id " + id + " in " + this);
                    this.values[name] = id;
                } else
                    this.valuesById[this.values[name] = id] = name;

                this.comments[name] = comment || null;
                return this;
            };

            /**
             * Removes a value from this enum
             * @param {string} name Value name
             * @returns {Enum} `this`
             * @throws {TypeError} If arguments are invalid
             * @throws {Error} If `name` is not a name of this enum
             */
            Enum.prototype.remove = function remove(name) {

                if (!util.isString(name))
                    throw TypeError("name must be a string");

                var val = this.values[name];
                if (val == null)
                    throw Error("name '" + name + "' does not exist in " + this);

                delete this.valuesById[val];
                delete this.values[name];
                delete this.comments[name];

                return this;
            };

            /**
             * Tests if the specified id is reserved.
             * @param {number} id Id to test
             * @returns {boolean} `true` if reserved, otherwise `false`
             */
            Enum.prototype.isReservedId = function isReservedId(id) {
                return Namespace.isReservedId(this.reserved, id);
            };

            /**
             * Tests if the specified name is reserved.
             * @param {string} name Name to test
             * @returns {boolean} `true` if reserved, otherwise `false`
             */
            Enum.prototype.isReservedName = function isReservedName(name) {
                return Namespace.isReservedName(this.reserved, name);
            };

        }, { "23": 23, "24": 24, "37": 37 }], 16: [function (require, module, exports) {
            "use strict";
            module.exports = Field;

            // extends ReflectionObject
            var ReflectionObject = require(24);
            ((Field.prototype = Object.create(ReflectionObject.prototype)).constructor = Field).className = "Field";

            var Enum = require(15),
                types = require(36),
                util = require(37);

            var Type; // cyclic

            var ruleRe = /^required|optional|repeated$/;

            /**
             * Constructs a new message field instance. Note that {@link MapField|map fields} have their own class.
             * @name Field
             * @classdesc Reflected message field.
             * @extends FieldBase
             * @constructor
             * @param {string} name Unique name within its namespace
             * @param {number} id Unique id within its namespace
             * @param {string} type Value type
             * @param {string|Object.<string,*>} [rule="optional"] Field rule
             * @param {string|Object.<string,*>} [extend] Extended type if different from parent
             * @param {Object.<string,*>} [options] Declared options
             */

            /**
             * Constructs a field from a field descriptor.
             * @param {string} name Field name
             * @param {IField} json Field descriptor
             * @returns {Field} Created field
             * @throws {TypeError} If arguments are invalid
             */
            Field.fromJSON = function fromJSON(name, json) {
                return new Field(name, json.id, json.type, json.rule, json.extend, json.options);
            };

            /**
             * Not an actual constructor. Use {@link Field} instead.
             * @classdesc Base class of all reflected message fields. This is not an actual class but here for the sake of having consistent type definitions.
             * @exports FieldBase
             * @extends ReflectionObject
             * @constructor
             * @param {string} name Unique name within its namespace
             * @param {number} id Unique id within its namespace
             * @param {string} type Value type
             * @param {string|Object.<string,*>} [rule="optional"] Field rule
             * @param {string|Object.<string,*>} [extend] Extended type if different from parent
             * @param {Object.<string,*>} [options] Declared options
             */
            function Field(name, id, type, rule, extend, options) {

                if (util.isObject(rule)) {
                    options = rule;
                    rule = extend = undefined;
                } else if (util.isObject(extend)) {
                    options = extend;
                    extend = undefined;
                }

                ReflectionObject.call(this, name, options);

                if (!util.isInteger(id) || id < 0)
                    throw TypeError("id must be a non-negative integer");

                if (!util.isString(type))
                    throw TypeError("type must be a string");

                if (rule !== undefined && !ruleRe.test(rule = rule.toString().toLowerCase()))
                    throw TypeError("rule must be a string rule");

                if (extend !== undefined && !util.isString(extend))
                    throw TypeError("extend must be a string");

                /**
                 * Field rule, if any.
                 * @type {string|undefined}
                 */
                this.rule = rule && rule !== "optional" ? rule : undefined; // toJSON

                /**
                 * Field type.
                 * @type {string}
                 */
                this.type = type; // toJSON

                /**
                 * Unique field id.
                 * @type {number}
                 */
                this.id = id; // toJSON, marker

                /**
                 * Extended type if different from parent.
                 * @type {string|undefined}
                 */
                this.extend = extend || undefined; // toJSON

                /**
                 * Whether this field is required.
                 * @type {boolean}
                 */
                this.required = rule === "required";

                /**
                 * Whether this field is optional.
                 * @type {boolean}
                 */
                this.optional = !this.required;

                /**
                 * Whether this field is repeated.
                 * @type {boolean}
                 */
                this.repeated = rule === "repeated";

                /**
                 * Whether this field is a map or not.
                 * @type {boolean}
                 */
                this.map = false;

                /**
                 * Message this field belongs to.
                 * @type {Type|null}
                 */
                this.message = null;

                /**
                 * OneOf this field belongs to, if any,
                 * @type {OneOf|null}
                 */
                this.partOf = null;

                /**
                 * The field type's default value.
                 * @type {*}
                 */
                this.typeDefault = null;

                /**
                 * The field's default value on prototypes.
                 * @type {*}
                 */
                this.defaultValue = null;

                /**
                 * Whether this field's value should be treated as a long.
                 * @type {boolean}
                 */
                this.long = util.Long ? types.long[type] !== undefined : /* istanbul ignore next */ false;

                /**
                 * Whether this field's value is a buffer.
                 * @type {boolean}
                 */
                this.bytes = type === "bytes";

                /**
                 * Resolved type if not a basic type.
                 * @type {Type|Enum|null}
                 */
                this.resolvedType = null;

                /**
                 * Sister-field within the extended type if a declaring extension field.
                 * @type {Field|null}
                 */
                this.extensionField = null;

                /**
                 * Sister-field within the declaring namespace if an extended field.
                 * @type {Field|null}
                 */
                this.declaringField = null;

                /**
                 * Internally remembers whether this field is packed.
                 * @type {boolean|null}
                 * @private
                 */
                this._packed = null;
            }

            /**
             * Determines whether this field is packed. Only relevant when repeated and working with proto2.
             * @name Field#packed
             * @type {boolean}
             * @readonly
             */
            Object.defineProperty(Field.prototype, "packed", {
                get: function () {
                    // defaults to packed=true if not explicity set to false
                    if (this._packed === null)
                        this._packed = this.getOption("packed") !== false;
                    return this._packed;
                }
            });

            /**
             * @override
             */
            Field.prototype.setOption = function setOption(name, value, ifNotSet) {
                if (name === "packed") // clear cached before setting
                    this._packed = null;
                return ReflectionObject.prototype.setOption.call(this, name, value, ifNotSet);
            };

            /**
             * Field descriptor.
             * @interface IField
             * @property {string} [rule="optional"] Field rule
             * @property {string} type Field type
             * @property {number} id Field id
             * @property {Object.<string,*>} [options] Field options
             */

            /**
             * Extension field descriptor.
             * @interface IExtensionField
             * @extends IField
             * @property {string} extend Extended type
             */

            /**
             * Converts this field to a field descriptor.
             * @returns {IField} Field descriptor
             */
            Field.prototype.toJSON = function toJSON() {
                return util.toObject([
                    "rule", this.rule !== "optional" && this.rule || undefined,
                    "type", this.type,
                    "id", this.id,
                    "extend", this.extend,
                    "options", this.options
                ]);
            };

            /**
             * Resolves this field's type references.
             * @returns {Field} `this`
             * @throws {Error} If any reference cannot be resolved
             */
            Field.prototype.resolve = function resolve() {

                if (this.resolved)
                    return this;

                if ((this.typeDefault = types.defaults[this.type]) === undefined) { // if not a basic type, resolve it
                    this.resolvedType = (this.declaringField ? this.declaringField.parent : this.parent).lookupTypeOrEnum(this.type);
                    if (this.resolvedType instanceof Type)
                        this.typeDefault = null;
                    else // instanceof Enum
                        this.typeDefault = this.resolvedType.values[Object.keys(this.resolvedType.values) [0]]; // first defined
                }

                // use explicitly set default value if present
                if (this.options && this.options["default"] != null) {
                    this.typeDefault = this.options["default"];
                    if (this.resolvedType instanceof Enum && typeof this.typeDefault === "string")
                        this.typeDefault = this.resolvedType.values[this.typeDefault];
                }

                // remove unnecessary options
                if (this.options) {
                    if (this.options.packed === true || this.options.packed !== undefined && this.resolvedType && !(this.resolvedType instanceof Enum))
                        delete this.options.packed;
                    if (!Object.keys(this.options).length)
                        this.options = undefined;
                }

                // convert to internal data type if necesssary
                if (this.long) {
                    this.typeDefault = util.Long.fromNumber(this.typeDefault, this.type.charAt(0) === "u");

                    /* istanbul ignore else */
                    if (Object.freeze)
                        Object.freeze(this.typeDefault); // long instances are meant to be immutable anyway (i.e. use small int cache that even requires it)

                } else if (this.bytes && typeof this.typeDefault === "string") {
                    var buf;
                    if (util.base64.test(this.typeDefault))
                        util.base64.decode(this.typeDefault, buf = util.newBuffer(util.base64.length(this.typeDefault)), 0);
                    else
                        util.utf8.write(this.typeDefault, buf = util.newBuffer(util.utf8.length(this.typeDefault)), 0);
                    this.typeDefault = buf;
                }

                // take special care of maps and repeated fields
                if (this.map)
                    this.defaultValue = util.emptyObject;
                else if (this.repeated)
                    this.defaultValue = util.emptyArray;
                else
                    this.defaultValue = this.typeDefault;

                // ensure proper value on prototype
                if (this.parent instanceof Type)
                    this.parent.ctor.prototype[this.name] = this.defaultValue;

                return ReflectionObject.prototype.resolve.call(this);
            };

            /**
             * Decorator function as returned by {@link Field.d} and {@link MapField.d} (TypeScript).
             * @typedef FieldDecorator
             * @type {function}
             * @param {Object} prototype Target prototype
             * @param {string} fieldName Field name
             * @returns {undefined}
             */

            /**
             * Field decorator (TypeScript).
             * @name Field.d
             * @function
             * @param {number} fieldId Field id
             * @param {"double"|"float"|"int32"|"uint32"|"sint32"|"fixed32"|"sfixed32"|"int64"|"uint64"|"sint64"|"fixed64"|"sfixed64"|"string"|"bool"|"bytes"|Object} fieldType Field type
             * @param {"optional"|"required"|"repeated"} [fieldRule="optional"] Field rule
             * @param {T} [defaultValue] Default value
             * @returns {FieldDecorator} Decorator function
             * @template T extends number | number[] | Long | Long[] | string | string[] | boolean | boolean[] | Uint8Array | Uint8Array[] | Buffer | Buffer[]
             */
            Field.d = function decorateField(fieldId, fieldType, fieldRule, defaultValue) {

                // submessage: decorate the submessage and use its name as the type
                if (typeof fieldType === "function")
                    fieldType = util.decorateType(fieldType).name;

                // enum reference: create a reflected copy of the enum and keep reuseing it
                else if (fieldType && typeof fieldType === "object")
                    fieldType = util.decorateEnum(fieldType).name;

                return function fieldDecorator(prototype, fieldName) {
                    util.decorateType(prototype.constructor)
                        .add(new Field(fieldName, fieldId, fieldType, fieldRule, { "default": defaultValue }));
                };
            };

            /**
             * Field decorator (TypeScript).
             * @name Field.d
             * @function
             * @param {number} fieldId Field id
             * @param {Constructor<T>|string} fieldType Field type
             * @param {"optional"|"required"|"repeated"} [fieldRule="optional"] Field rule
             * @returns {FieldDecorator} Decorator function
             * @template T extends Message<T>
             * @variation 2
             */
            // like Field.d but without a default value

            Field._configure = function configure(Type_) {
                Type = Type_;
            };

        }, { "15": 15, "24": 24, "36": 36, "37": 37 }], 17: [function (require, module, exports) {
            "use strict";
            var protobuf = module.exports = require(18);

            protobuf.build = "light";

            /**
             * A node-style callback as used by {@link load} and {@link Root#load}.
             * @typedef LoadCallback
             * @type {function}
             * @param {Error|null} error Error, if any, otherwise `null`
             * @param {Root} [root] Root, if there hasn't been an error
             * @returns {undefined}
             */

            /**
             * Loads one or multiple .proto or preprocessed .json files into a common root namespace and calls the callback.
             * @param {string|string[]} filename One or multiple files to load
             * @param {Root} root Root namespace, defaults to create a new one if omitted.
             * @param {LoadCallback} callback Callback function
             * @returns {undefined}
             * @see {@link Root#load}
             */
            function load(filename, root, callback) {
                if (typeof root === "function") {
                    callback = root;
                    root = new protobuf.Root();
                } else if (!root)
                    root = new protobuf.Root();
                return root.load(filename, callback);
            }

            /**
             * Loads one or multiple .proto or preprocessed .json files into a common root namespace and calls the callback.
             * @name load
             * @function
             * @param {string|string[]} filename One or multiple files to load
             * @param {LoadCallback} callback Callback function
             * @returns {undefined}
             * @see {@link Root#load}
             * @variation 2
             */
            // function load(filename:string, callback:LoadCallback):undefined

            /**
             * Loads one or multiple .proto or preprocessed .json files into a common root namespace and returns a promise.
             * @name load
             * @function
             * @param {string|string[]} filename One or multiple files to load
             * @param {Root} [root] Root namespace, defaults to create a new one if omitted.
             * @returns {Promise<Root>} Promise
             * @see {@link Root#load}
             * @variation 3
             */
            // function load(filename:string, [root:Root]):Promise<Root>

            protobuf.load = load;

            /**
             * Synchronously loads one or multiple .proto or preprocessed .json files into a common root namespace (node only).
             * @param {string|string[]} filename One or multiple files to load
             * @param {Root} [root] Root namespace, defaults to create a new one if omitted.
             * @returns {Root} Root namespace
             * @throws {Error} If synchronous fetching is not supported (i.e. in browsers) or if a file's syntax is invalid
             * @see {@link Root#loadSync}
             */
            function loadSync(filename, root) {
                if (!root)
                    root = new protobuf.Root();
                return root.loadSync(filename);
            }

            protobuf.loadSync = loadSync;

            // Serialization
            protobuf.encoder = require(14);
            protobuf.decoder = require(13);
            protobuf.verifier = require(40);
            protobuf.converter = require(12);

            // Reflection
            protobuf.ReflectionObject = require(24);
            protobuf.Namespace = require(23);
            protobuf.Root = require(29);
            protobuf.Enum = require(15);
            protobuf.Type = require(35);
            protobuf.Field = require(16);
            protobuf.OneOf = require(25);
            protobuf.MapField = require(20);
            protobuf.Service = require(33);
            protobuf.Method = require(22);

            // Runtime
            protobuf.Message = require(21);
            protobuf.wrappers = require(41);

            // Utility
            protobuf.types = require(36);
            protobuf.util = require(37);

            // Configure reflection
            protobuf.ReflectionObject._configure(protobuf.Root);
            protobuf.Namespace._configure(protobuf.Type, protobuf.Service);
            protobuf.Root._configure(protobuf.Type);
            protobuf.Field._configure(protobuf.Type);

        }, { "12": 12, "13": 13, "14": 14, "15": 15, "16": 16, "18": 18, "20": 20, "21": 21, "22": 22, "23": 23, "24": 24, "25": 25, "29": 29, "33": 33, "35": 35, "36": 36, "37": 37, "40": 40, "41": 41 }], 18: [function (require, module, exports) {
            "use strict";
            var protobuf = exports;

            /**
             * Build type, one of `"full"`, `"light"` or `"minimal"`.
             * @name build
             * @type {string}
             * @const
             */
            protobuf.build = "minimal";

            // Serialization
            protobuf.Writer = require(42);
            protobuf.BufferWriter = require(43);
            protobuf.Reader = require(27);
            protobuf.BufferReader = require(28);

            // Utility
            protobuf.util = require(39);
            protobuf.rpc = require(31);
            protobuf.roots = require(30);
            protobuf.configure = configure;

            /* istanbul ignore next */
            /**
             * Reconfigures the library according to the environment.
             * @returns {undefined}
             */
            function configure() {
                protobuf.Reader._configure(protobuf.BufferReader);
                protobuf.util._configure();
            }

            // Configure serialization
            protobuf.Writer._configure(protobuf.BufferWriter);
            configure();

        }, { "27": 27, "28": 28, "30": 30, "31": 31, "39": 39, "42": 42, "43": 43 }], 19: [function (require, module, exports) {
            "use strict";
            var protobuf = module.exports = require(17);

            protobuf.build = "full";

            // Parser
            protobuf.tokenize = require(34);
            protobuf.parse = require(26);
            protobuf.common = require(11);

            // Configure parser
            protobuf.Root._configure(protobuf.Type, protobuf.parse, protobuf.common);

        }, { "11": 11, "17": 17, "26": 26, "34": 34 }], 20: [function (require, module, exports) {
            "use strict";
            module.exports = MapField;

            // extends Field
            var Field = require(16);
            ((MapField.prototype = Object.create(Field.prototype)).constructor = MapField).className = "MapField";

            var types = require(36),
                util = require(37);

            /**
             * Constructs a new map field instance.
             * @classdesc Reflected map field.
             * @extends FieldBase
             * @constructor
             * @param {string} name Unique name within its namespace
             * @param {number} id Unique id within its namespace
             * @param {string} keyType Key type
             * @param {string} type Value type
             * @param {Object.<string,*>} [options] Declared options
             */
            function MapField(name, id, keyType, type, options) {
                Field.call(this, name, id, type, options);

                /* istanbul ignore if */
                if (!util.isString(keyType))
                    throw TypeError("keyType must be a string");

                /**
                 * Key type.
                 * @type {string}
                 */
                this.keyType = keyType; // toJSON, marker

                /**
                 * Resolved key type if not a basic type.
                 * @type {ReflectionObject|null}
                 */
                this.resolvedKeyType = null;

                // Overrides Field#map
                this.map = true;
            }

            /**
             * Map field descriptor.
             * @interface IMapField
             * @extends {IField}
             * @property {string} keyType Key type
             */

            /**
             * Extension map field descriptor.
             * @interface IExtensionMapField
             * @extends IMapField
             * @property {string} extend Extended type
             */

            /**
             * Constructs a map field from a map field descriptor.
             * @param {string} name Field name
             * @param {IMapField} json Map field descriptor
             * @returns {MapField} Created map field
             * @throws {TypeError} If arguments are invalid
             */
            MapField.fromJSON = function fromJSON(name, json) {
                return new MapField(name, json.id, json.keyType, json.type, json.options);
            };

            /**
             * Converts this map field to a map field descriptor.
             * @returns {IMapField} Map field descriptor
             */
            MapField.prototype.toJSON = function toJSON() {
                return util.toObject([
                    "keyType", this.keyType,
                    "type", this.type,
                    "id", this.id,
                    "extend", this.extend,
                    "options", this.options
                ]);
            };

            /**
             * @override
             */
            MapField.prototype.resolve = function resolve() {
                if (this.resolved)
                    return this;

                // Besides a value type, map fields have a key type that may be "any scalar type except for floating point types and bytes"
                if (types.mapKey[this.keyType] === undefined)
                    throw Error("invalid key type: " + this.keyType);

                return Field.prototype.resolve.call(this);
            };

            /**
             * Map field decorator (TypeScript).
             * @name MapField.d
             * @function
             * @param {number} fieldId Field id
             * @param {"int32"|"uint32"|"sint32"|"fixed32"|"sfixed32"|"int64"|"uint64"|"sint64"|"fixed64"|"sfixed64"|"bool"|"string"} fieldKeyType Field key type
             * @param {"double"|"float"|"int32"|"uint32"|"sint32"|"fixed32"|"sfixed32"|"int64"|"uint64"|"sint64"|"fixed64"|"sfixed64"|"bool"|"string"|"bytes"|Object|Constructor<{}>} fieldValueType Field value type
             * @returns {FieldDecorator} Decorator function
             * @template T extends { [key: string]: number | Long | string | boolean | Uint8Array | Buffer | number[] | Message<{}> }
             */
            MapField.d = function decorateMapField(fieldId, fieldKeyType, fieldValueType) {

                // submessage value: decorate the submessage and use its name as the type
                if (typeof fieldValueType === "function")
                    fieldValueType = util.decorateType(fieldValueType).name;

                // enum reference value: create a reflected copy of the enum and keep reuseing it
                else if (fieldValueType && typeof fieldValueType === "object")
                    fieldValueType = util.decorateEnum(fieldValueType).name;

                return function mapFieldDecorator(prototype, fieldName) {
                    util.decorateType(prototype.constructor)
                        .add(new MapField(fieldName, fieldId, fieldKeyType, fieldValueType));
                };
            };

        }, { "16": 16, "36": 36, "37": 37 }], 21: [function (require, module, exports) {
            "use strict";
            module.exports = Message;

            var util = require(39);

            /**
             * Constructs a new message instance.
             * @classdesc Abstract runtime message.
             * @constructor
             * @param {Properties<T>} [properties] Properties to set
             * @template T extends object
             */
            function Message(properties) {
                // not used internally
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        this[keys[i]] = properties[keys[i]];
            }

            /**
             * Reference to the reflected type.
             * @name Message.$type
             * @type {Type}
             * @readonly
             */

            /**
             * Reference to the reflected type.
             * @name Message#$type
             * @type {Type}
             * @readonly
             */

            /*eslint-disable valid-jsdoc*/

            /**
             * Creates a new message of this type using the specified properties.
             * @param {Object.<string,*>} [properties] Properties to set
             * @returns {Message<T>} Message instance
             * @template T extends Message<T>
             * @this Constructor<T>
             */
            Message.create = function create(properties) {
                return this.$type.create(properties);
            };

            /**
             * Encodes a message of this type.
             * @param {T|Object.<string,*>} message Message to encode
             * @param {Writer} [writer] Writer to use
             * @returns {Writer} Writer
             * @template T extends Message<T>
             * @this Constructor<T>
             */
            Message.encode = function encode(message, writer) {
                return this.$type.encode(message, writer);
            };

            /**
             * Encodes a message of this type preceeded by its length as a varint.
             * @param {T|Object.<string,*>} message Message to encode
             * @param {Writer} [writer] Writer to use
             * @returns {Writer} Writer
             * @template T extends Message<T>
             * @this Constructor<T>
             */
            Message.encodeDelimited = function encodeDelimited(message, writer) {
                return this.$type.encodeDelimited(message, writer);
            };

            /**
             * Decodes a message of this type.
             * @name Message.decode
             * @function
             * @param {Reader|Uint8Array} reader Reader or buffer to decode
             * @returns {T} Decoded message
             * @template T extends Message<T>
             * @this Constructor<T>
             */
            Message.decode = function decode(reader) {
                return this.$type.decode(reader);
            };

            /**
             * Decodes a message of this type preceeded by its length as a varint.
             * @name Message.decodeDelimited
             * @function
             * @param {Reader|Uint8Array} reader Reader or buffer to decode
             * @returns {T} Decoded message
             * @template T extends Message<T>
             * @this Constructor<T>
             */
            Message.decodeDelimited = function decodeDelimited(reader) {
                return this.$type.decodeDelimited(reader);
            };

            /**
             * Verifies a message of this type.
             * @name Message.verify
             * @function
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            Message.verify = function verify(message) {
                return this.$type.verify(message);
            };

            /**
             * Creates a new message of this type from a plain object. Also converts values to their respective internal types.
             * @param {Object.<string,*>} object Plain object
             * @returns {T} Message instance
             * @template T extends Message<T>
             * @this Constructor<T>
             */
            Message.fromObject = function fromObject(object) {
                return this.$type.fromObject(object);
            };

            /**
             * Creates a plain object from a message of this type. Also converts values to other types if specified.
             * @param {T} message Message instance
             * @param {IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             * @template T extends Message<T>
             * @this Constructor<T>
             */
            Message.toObject = function toObject(message, options) {
                return this.$type.toObject(message, options);
            };

            /**
             * Converts this message to JSON.
             * @returns {Object.<string,*>} JSON object
             */
            Message.prototype.toJSON = function toJSON() {
                return this.$type.toObject(this, util.toJSONOptions);
            };

            /*eslint-enable valid-jsdoc*/
        }, { "39": 39 }], 22: [function (require, module, exports) {
            "use strict";
            module.exports = Method;

            // extends ReflectionObject
            var ReflectionObject = require(24);
            ((Method.prototype = Object.create(ReflectionObject.prototype)).constructor = Method).className = "Method";

            var util = require(37);

            /**
             * Constructs a new service method instance.
             * @classdesc Reflected service method.
             * @extends ReflectionObject
             * @constructor
             * @param {string} name Method name
             * @param {string|undefined} type Method type, usually `"rpc"`
             * @param {string} requestType Request message type
             * @param {string} responseType Response message type
             * @param {boolean|Object.<string,*>} [requestStream] Whether the request is streamed
             * @param {boolean|Object.<string,*>} [responseStream] Whether the response is streamed
             * @param {Object.<string,*>} [options] Declared options
             */
            function Method(name, type, requestType, responseType, requestStream, responseStream, options) {

                /* istanbul ignore next */
                if (util.isObject(requestStream)) {
                    options = requestStream;
                    requestStream = responseStream = undefined;
                } else if (util.isObject(responseStream)) {
                    options = responseStream;
                    responseStream = undefined;
                }

                /* istanbul ignore if */
                if (!(type === undefined || util.isString(type)))
                    throw TypeError("type must be a string");

                /* istanbul ignore if */
                if (!util.isString(requestType))
                    throw TypeError("requestType must be a string");

                /* istanbul ignore if */
                if (!util.isString(responseType))
                    throw TypeError("responseType must be a string");

                ReflectionObject.call(this, name, options);

                /**
                 * Method type.
                 * @type {string}
                 */
                this.type = type || "rpc"; // toJSON

                /**
                 * Request type.
                 * @type {string}
                 */
                this.requestType = requestType; // toJSON, marker

                /**
                 * Whether requests are streamed or not.
                 * @type {boolean|undefined}
                 */
                this.requestStream = requestStream ? true : undefined; // toJSON

                /**
                 * Response type.
                 * @type {string}
                 */
                this.responseType = responseType; // toJSON

                /**
                 * Whether responses are streamed or not.
                 * @type {boolean|undefined}
                 */
                this.responseStream = responseStream ? true : undefined; // toJSON

                /**
                 * Resolved request type.
                 * @type {Type|null}
                 */
                this.resolvedRequestType = null;

                /**
                 * Resolved response type.
                 * @type {Type|null}
                 */
                this.resolvedResponseType = null;
            }

            /**
             * Method descriptor.
             * @interface IMethod
             * @property {string} [type="rpc"] Method type
             * @property {string} requestType Request type
             * @property {string} responseType Response type
             * @property {boolean} [requestStream=false] Whether requests are streamed
             * @property {boolean} [responseStream=false] Whether responses are streamed
             * @property {Object.<string,*>} [options] Method options
             */

            /**
             * Constructs a method from a method descriptor.
             * @param {string} name Method name
             * @param {IMethod} json Method descriptor
             * @returns {Method} Created method
             * @throws {TypeError} If arguments are invalid
             */
            Method.fromJSON = function fromJSON(name, json) {
                return new Method(name, json.type, json.requestType, json.responseType, json.requestStream, json.responseStream, json.options);
            };

            /**
             * Converts this method to a method descriptor.
             * @returns {IMethod} Method descriptor
             */
            Method.prototype.toJSON = function toJSON() {
                return util.toObject([
                    "type", this.type !== "rpc" && /* istanbul ignore next */ this.type || undefined,
                    "requestType", this.requestType,
                    "requestStream", this.requestStream,
                    "responseType", this.responseType,
                    "responseStream", this.responseStream,
                    "options", this.options
                ]);
            };

            /**
             * @override
             */
            Method.prototype.resolve = function resolve() {

                /* istanbul ignore if */
                if (this.resolved)
                    return this;

                this.resolvedRequestType = this.parent.lookupType(this.requestType);
                this.resolvedResponseType = this.parent.lookupType(this.responseType);

                return ReflectionObject.prototype.resolve.call(this);
            };

        }, { "24": 24, "37": 37 }], 23: [function (require, module, exports) {
            "use strict";
            module.exports = Namespace;

            // extends ReflectionObject
            var ReflectionObject = require(24);
            ((Namespace.prototype = Object.create(ReflectionObject.prototype)).constructor = Namespace).className = "Namespace";

            var Enum = require(15),
                Field = require(16),
                util = require(37);

            var Type,    // cyclic
                Service; // "

            /**
             * Constructs a new namespace instance.
             * @name Namespace
             * @classdesc Reflected namespace.
             * @extends NamespaceBase
             * @constructor
             * @param {string} name Namespace name
             * @param {Object.<string,*>} [options] Declared options
             */

            /**
             * Constructs a namespace from JSON.
             * @memberof Namespace
             * @function
             * @param {string} name Namespace name
             * @param {Object.<string,*>} json JSON object
             * @returns {Namespace} Created namespace
             * @throws {TypeError} If arguments are invalid
             */
            Namespace.fromJSON = function fromJSON(name, json) {
                return new Namespace(name, json.options).addJSON(json.nested);
            };

            /**
             * Converts an array of reflection objects to JSON.
             * @memberof Namespace
             * @param {ReflectionObject[]} array Object array
             * @returns {Object.<string,*>|undefined} JSON object or `undefined` when array is empty
             */
            function arrayToJSON(array) {
                if (!(array && array.length))
                    return undefined;
                var obj = {};
                for (var i = 0; i < array.length; ++i)
                    obj[array[i].name] = array[i].toJSON();
                return obj;
            }

            Namespace.arrayToJSON = arrayToJSON;

            /**
             * Tests if the specified id is reserved.
             * @param {Array.<number[]|string>|undefined} reserved Array of reserved ranges and names
             * @param {number} id Id to test
             * @returns {boolean} `true` if reserved, otherwise `false`
             */
            Namespace.isReservedId = function isReservedId(reserved, id) {
                if (reserved)
                    for (var i = 0; i < reserved.length; ++i)
                        if (typeof reserved[i] !== "string" && reserved[i][0] <= id && reserved[i][1] >= id)
                            return true;
                return false;
            };

            /**
             * Tests if the specified name is reserved.
             * @param {Array.<number[]|string>|undefined} reserved Array of reserved ranges and names
             * @param {string} name Name to test
             * @returns {boolean} `true` if reserved, otherwise `false`
             */
            Namespace.isReservedName = function isReservedName(reserved, name) {
                if (reserved)
                    for (var i = 0; i < reserved.length; ++i)
                        if (reserved[i] === name)
                            return true;
                return false;
            };

            /**
             * Not an actual constructor. Use {@link Namespace} instead.
             * @classdesc Base class of all reflection objects containing nested objects. This is not an actual class but here for the sake of having consistent type definitions.
             * @exports NamespaceBase
             * @extends ReflectionObject
             * @abstract
             * @constructor
             * @param {string} name Namespace name
             * @param {Object.<string,*>} [options] Declared options
             * @see {@link Namespace}
             */
            function Namespace(name, options) {
                ReflectionObject.call(this, name, options);

                /**
                 * Nested objects by name.
                 * @type {Object.<string,ReflectionObject>|undefined}
                 */
                this.nested = undefined; // toJSON

                /**
                 * Cached nested objects as an array.
                 * @type {ReflectionObject[]|null}
                 * @private
                 */
                this._nestedArray = null;
            }

            function clearCache(namespace) {
                namespace._nestedArray = null;
                return namespace;
            }

            /**
             * Nested objects of this namespace as an array for iteration.
             * @name NamespaceBase#nestedArray
             * @type {ReflectionObject[]}
             * @readonly
             */
            Object.defineProperty(Namespace.prototype, "nestedArray", {
                get: function () {
                    return this._nestedArray || (this._nestedArray = util.toArray(this.nested));
                }
            });

            /**
             * Namespace descriptor.
             * @interface INamespace
             * @property {Object.<string,*>} [options] Namespace options
             * @property {Object.<string,AnyNestedObject>} [nested] Nested object descriptors
             */

            /**
             * Any extension field descriptor.
             * @typedef AnyExtensionField
             * @type {IExtensionField|IExtensionMapField}
             */

            /**
             * Any nested object descriptor.
             * @typedef AnyNestedObject
             * @type {IEnum|IType|IService|AnyExtensionField|INamespace}
             */
            // ^ BEWARE: VSCode hangs forever when using more than 5 types (that's why AnyExtensionField exists in the first place)

            /**
             * Converts this namespace to a namespace descriptor.
             * @returns {INamespace} Namespace descriptor
             */
            Namespace.prototype.toJSON = function toJSON() {
                return util.toObject([
                    "options", this.options,
                    "nested", arrayToJSON(this.nestedArray)
                ]);
            };

            /**
             * Adds nested objects to this namespace from nested object descriptors.
             * @param {Object.<string,AnyNestedObject>} nestedJson Any nested object descriptors
             * @returns {Namespace} `this`
             */
            Namespace.prototype.addJSON = function addJSON(nestedJson) {
                var ns = this;
                /* istanbul ignore else */
                if (nestedJson) {
                    for (var names = Object.keys(nestedJson), i = 0, nested; i < names.length; ++i) {
                        nested = nestedJson[names[i]];
                        ns.add( // most to least likely
                            (nested.fields !== undefined
                                ? Type.fromJSON
                                : nested.values !== undefined
                                    ? Enum.fromJSON
                                    : nested.methods !== undefined
                                        ? Service.fromJSON
                                        : nested.id !== undefined
                                            ? Field.fromJSON
                                            : Namespace.fromJSON)(names[i], nested)
                        );
                    }
                }
                return this;
            };

            /**
             * Gets the nested object of the specified name.
             * @param {string} name Nested object name
             * @returns {ReflectionObject|null} The reflection object or `null` if it doesn't exist
             */
            Namespace.prototype.get = function get(name) {
                return this.nested && this.nested[name]
                    || null;
            };

            /**
             * Gets the values of the nested {@link Enum|enum} of the specified name.
             * This methods differs from {@link Namespace#get|get} in that it returns an enum's values directly and throws instead of returning `null`.
             * @param {string} name Nested enum name
             * @returns {Object.<string,number>} Enum values
             * @throws {Error} If there is no such enum
             */
            Namespace.prototype.getEnum = function getEnum(name) {
                if (this.nested && this.nested[name] instanceof Enum)
                    return this.nested[name].values;
                throw Error("no such enum");
            };

            /**
             * Adds a nested object to this namespace.
             * @param {ReflectionObject} object Nested object to add
             * @returns {Namespace} `this`
             * @throws {TypeError} If arguments are invalid
             * @throws {Error} If there is already a nested object with this name
             */
            Namespace.prototype.add = function add(object) {

                if (!(object instanceof Field && object.extend !== undefined || object instanceof Type || object instanceof Enum || object instanceof Service || object instanceof Namespace))
                    throw TypeError("object must be a valid nested object");

                if (!this.nested)
                    this.nested = {};
                else {
                    var prev = this.get(object.name);
                    if (prev) {
                        if (prev instanceof Namespace && object instanceof Namespace && !(prev instanceof Type || prev instanceof Service)) {
                            // replace plain namespace but keep existing nested elements and options
                            var nested = prev.nestedArray;
                            for (var i = 0; i < nested.length; ++i)
                                object.add(nested[i]);
                            this.remove(prev);
                            if (!this.nested)
                                this.nested = {};
                            object.setOptions(prev.options, true);

                        } else
                            throw Error("duplicate name '" + object.name + "' in " + this);
                    }
                }
                this.nested[object.name] = object;
                object.onAdd(this);
                return clearCache(this);
            };

            /**
             * Removes a nested object from this namespace.
             * @param {ReflectionObject} object Nested object to remove
             * @returns {Namespace} `this`
             * @throws {TypeError} If arguments are invalid
             * @throws {Error} If `object` is not a member of this namespace
             */
            Namespace.prototype.remove = function remove(object) {

                if (!(object instanceof ReflectionObject))
                    throw TypeError("object must be a ReflectionObject");
                if (object.parent !== this)
                    throw Error(object + " is not a member of " + this);

                delete this.nested[object.name];
                if (!Object.keys(this.nested).length)
                    this.nested = undefined;

                object.onRemove(this);
                return clearCache(this);
            };

            /**
             * Defines additial namespaces within this one if not yet existing.
             * @param {string|string[]} path Path to create
             * @param {*} [json] Nested types to create from JSON
             * @returns {Namespace} Pointer to the last namespace created or `this` if path is empty
             */
            Namespace.prototype.define = function define(path, json) {

                if (util.isString(path))
                    path = path.split(".");
                else if (!Array.isArray(path))
                    throw TypeError("illegal path");
                if (path && path.length && path[0] === "")
                    throw Error("path must be relative");

                var ptr = this;
                while (path.length > 0) {
                    var part = path.shift();
                    if (ptr.nested && ptr.nested[part]) {
                        ptr = ptr.nested[part];
                        if (!(ptr instanceof Namespace))
                            throw Error("path conflicts with non-namespace objects");
                    } else
                        ptr.add(ptr = new Namespace(part));
                }
                if (json)
                    ptr.addJSON(json);
                return ptr;
            };

            /**
             * Resolves this namespace's and all its nested objects' type references. Useful to validate a reflection tree, but comes at a cost.
             * @returns {Namespace} `this`
             */
            Namespace.prototype.resolveAll = function resolveAll() {
                var nested = this.nestedArray, i = 0;
                while (i < nested.length)
                    if (nested[i] instanceof Namespace)
                        nested[i++].resolveAll();
                    else
                        nested[i++].resolve();
                return this.resolve();
            };

            /**
             * Recursively looks up the reflection object matching the specified path in the scope of this namespace.
             * @param {string|string[]} path Path to look up
             * @param {*|Array.<*>} filterTypes Filter types, any combination of the constructors of `protobuf.Type`, `protobuf.Enum`, `protobuf.Service` etc.
             * @param {boolean} [parentAlreadyChecked=false] If known, whether the parent has already been checked
             * @returns {ReflectionObject|null} Looked up object or `null` if none could be found
             */
            Namespace.prototype.lookup = function lookup(path, filterTypes, parentAlreadyChecked) {

                /* istanbul ignore next */
                if (typeof filterTypes === "boolean") {
                    parentAlreadyChecked = filterTypes;
                    filterTypes = undefined;
                } else if (filterTypes && !Array.isArray(filterTypes))
                    filterTypes = [filterTypes];

                if (util.isString(path) && path.length) {
                    if (path === ".")
                        return this.root;
                    path = path.split(".");
                } else if (!path.length)
                    return this;

                // Start at root if path is absolute
                if (path[0] === "")
                    return this.root.lookup(path.slice(1), filterTypes);

                // Test if the first part matches any nested object, and if so, traverse if path contains more
                var found = this.get(path[0]);
                if (found) {
                    if (path.length === 1) {
                        if (!filterTypes || filterTypes.indexOf(found.constructor) > -1)
                            return found;
                    } else if (found instanceof Namespace && (found = found.lookup(path.slice(1), filterTypes, true)))
                        return found;

                    // Otherwise try each nested namespace
                } else
                    for (var i = 0; i < this.nestedArray.length; ++i)
                        if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i].lookup(path, filterTypes, true)))
                            return found;

                // If there hasn't been a match, try again at the parent
                if (this.parent === null || parentAlreadyChecked)
                    return null;
                return this.parent.lookup(path, filterTypes);
            };

            /**
             * Looks up the reflection object at the specified path, relative to this namespace.
             * @name NamespaceBase#lookup
             * @function
             * @param {string|string[]} path Path to look up
             * @param {boolean} [parentAlreadyChecked=false] Whether the parent has already been checked
             * @returns {ReflectionObject|null} Looked up object or `null` if none could be found
             * @variation 2
             */
            // lookup(path: string, [parentAlreadyChecked: boolean])

            /**
             * Looks up the {@link Type|type} at the specified path, relative to this namespace.
             * Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
             * @param {string|string[]} path Path to look up
             * @returns {Type} Looked up type
             * @throws {Error} If `path` does not point to a type
             */
            Namespace.prototype.lookupType = function lookupType(path) {
                var found = this.lookup(path, [Type]);
                if (!found)
                    throw Error("no such type");
                return found;
            };

            /**
             * Looks up the values of the {@link Enum|enum} at the specified path, relative to this namespace.
             * Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
             * @param {string|string[]} path Path to look up
             * @returns {Enum} Looked up enum
             * @throws {Error} If `path` does not point to an enum
             */
            Namespace.prototype.lookupEnum = function lookupEnum(path) {
                var found = this.lookup(path, [Enum]);
                if (!found)
                    throw Error("no such Enum '" + path + "' in " + this);
                return found;
            };

            /**
             * Looks up the {@link Type|type} or {@link Enum|enum} at the specified path, relative to this namespace.
             * Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
             * @param {string|string[]} path Path to look up
             * @returns {Type} Looked up type or enum
             * @throws {Error} If `path` does not point to a type or enum
             */
            Namespace.prototype.lookupTypeOrEnum = function lookupTypeOrEnum(path) {
                var found = this.lookup(path, [Type, Enum]);
                if (!found)
                    throw Error("no such Type or Enum '" + path + "' in " + this);
                return found;
            };

            /**
             * Looks up the {@link Service|service} at the specified path, relative to this namespace.
             * Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
             * @param {string|string[]} path Path to look up
             * @returns {Service} Looked up service
             * @throws {Error} If `path` does not point to a service
             */
            Namespace.prototype.lookupService = function lookupService(path) {
                var found = this.lookup(path, [Service]);
                if (!found)
                    throw Error("no such Service '" + path + "' in " + this);
                return found;
            };

            Namespace._configure = function (Type_, Service_) {
                Type = Type_;
                Service = Service_;
            };

        }, { "15": 15, "16": 16, "24": 24, "37": 37 }], 24: [function (require, module, exports) {
            "use strict";
            module.exports = ReflectionObject;

            ReflectionObject.className = "ReflectionObject";

            var util = require(37);

            var Root; // cyclic

            /**
             * Constructs a new reflection object instance.
             * @classdesc Base class of all reflection objects.
             * @constructor
             * @param {string} name Object name
             * @param {Object.<string,*>} [options] Declared options
             * @abstract
             */
            function ReflectionObject(name, options) {

                if (!util.isString(name))
                    throw TypeError("name must be a string");

                if (options && !util.isObject(options))
                    throw TypeError("options must be an object");

                /**
                 * Options.
                 * @type {Object.<string,*>|undefined}
                 */
                this.options = options; // toJSON

                /**
                 * Unique name within its namespace.
                 * @type {string}
                 */
                this.name = name;

                /**
                 * Parent namespace.
                 * @type {Namespace|null}
                 */
                this.parent = null;

                /**
                 * Whether already resolved or not.
                 * @type {boolean}
                 */
                this.resolved = false;

                /**
                 * Comment text, if any.
                 * @type {string|null}
                 */
                this.comment = null;

                /**
                 * Defining file name.
                 * @type {string|null}
                 */
                this.filename = null;
            }

            Object.defineProperties(ReflectionObject.prototype, {

                /**
                 * Reference to the root namespace.
                 * @name ReflectionObject#root
                 * @type {Root}
                 * @readonly
                 */
                root: {
                    get: function () {
                        var ptr = this;
                        while (ptr.parent !== null)
                            ptr = ptr.parent;
                        return ptr;
                    }
                },

                /**
                 * Full name including leading dot.
                 * @name ReflectionObject#fullName
                 * @type {string}
                 * @readonly
                 */
                fullName: {
                    get: function () {
                        var path = [this.name],
                            ptr = this.parent;
                        while (ptr) {
                            path.unshift(ptr.name);
                            ptr = ptr.parent;
                        }
                        return path.join(".");
                    }
                }
            });

            /**
             * Converts this reflection object to its descriptor representation.
             * @returns {Object.<string,*>} Descriptor
             * @abstract
             */
            ReflectionObject.prototype.toJSON = /* istanbul ignore next */ function toJSON() {
                throw Error(); // not implemented, shouldn't happen
            };

            /**
             * Called when this object is added to a parent.
             * @param {ReflectionObject} parent Parent added to
             * @returns {undefined}
             */
            ReflectionObject.prototype.onAdd = function onAdd(parent) {
                if (this.parent && this.parent !== parent)
                    this.parent.remove(this);
                this.parent = parent;
                this.resolved = false;
                var root = parent.root;
                if (root instanceof Root)
                    root._handleAdd(this);
            };

            /**
             * Called when this object is removed from a parent.
             * @param {ReflectionObject} parent Parent removed from
             * @returns {undefined}
             */
            ReflectionObject.prototype.onRemove = function onRemove(parent) {
                var root = parent.root;
                if (root instanceof Root)
                    root._handleRemove(this);
                this.parent = null;
                this.resolved = false;
            };

            /**
             * Resolves this objects type references.
             * @returns {ReflectionObject} `this`
             */
            ReflectionObject.prototype.resolve = function resolve() {
                if (this.resolved)
                    return this;
                if (this.root instanceof Root)
                    this.resolved = true; // only if part of a root
                return this;
            };

            /**
             * Gets an option value.
             * @param {string} name Option name
             * @returns {*} Option value or `undefined` if not set
             */
            ReflectionObject.prototype.getOption = function getOption(name) {
                if (this.options)
                    return this.options[name];
                return undefined;
            };

            /**
             * Sets an option.
             * @param {string} name Option name
             * @param {*} value Option value
             * @param {boolean} [ifNotSet] Sets the option only if it isn't currently set
             * @returns {ReflectionObject} `this`
             */
            ReflectionObject.prototype.setOption = function setOption(name, value, ifNotSet) {
                if (!ifNotSet || !this.options || this.options[name] === undefined)
                    (this.options || (this.options = {})) [name] = value;
                return this;
            };

            /**
             * Sets multiple options.
             * @param {Object.<string,*>} options Options to set
             * @param {boolean} [ifNotSet] Sets an option only if it isn't currently set
             * @returns {ReflectionObject} `this`
             */
            ReflectionObject.prototype.setOptions = function setOptions(options, ifNotSet) {
                if (options)
                    for (var keys = Object.keys(options), i = 0; i < keys.length; ++i)
                        this.setOption(keys[i], options[keys[i]], ifNotSet);
                return this;
            };

            /**
             * Converts this instance to its string representation.
             * @returns {string} Class name[, space, full name]
             */
            ReflectionObject.prototype.toString = function toString() {
                var className = this.constructor.className,
                    fullName = this.fullName;
                if (fullName.length)
                    return className + " " + fullName;
                return className;
            };

            ReflectionObject._configure = function (Root_) {
                Root = Root_;
            };

        }, { "37": 37 }], 25: [function (require, module, exports) {
            "use strict";
            module.exports = OneOf;

            // extends ReflectionObject
            var ReflectionObject = require(24);
            ((OneOf.prototype = Object.create(ReflectionObject.prototype)).constructor = OneOf).className = "OneOf";

            var Field = require(16),
                util = require(37);

            /**
             * Constructs a new oneof instance.
             * @classdesc Reflected oneof.
             * @extends ReflectionObject
             * @constructor
             * @param {string} name Oneof name
             * @param {string[]|Object.<string,*>} [fieldNames] Field names
             * @param {Object.<string,*>} [options] Declared options
             */
            function OneOf(name, fieldNames, options) {
                if (!Array.isArray(fieldNames)) {
                    options = fieldNames;
                    fieldNames = undefined;
                }
                ReflectionObject.call(this, name, options);

                /* istanbul ignore if */
                if (!(fieldNames === undefined || Array.isArray(fieldNames)))
                    throw TypeError("fieldNames must be an Array");

                /**
                 * Field names that belong to this oneof.
                 * @type {string[]}
                 */
                this.oneof = fieldNames || []; // toJSON, marker

                /**
                 * Fields that belong to this oneof as an array for iteration.
                 * @type {Field[]}
                 * @readonly
                 */
                this.fieldsArray = []; // declared readonly for conformance, possibly not yet added to parent
            }

            /**
             * Oneof descriptor.
             * @interface IOneOf
             * @property {Array.<string>} oneof Oneof field names
             * @property {Object.<string,*>} [options] Oneof options
             */

            /**
             * Constructs a oneof from a oneof descriptor.
             * @param {string} name Oneof name
             * @param {IOneOf} json Oneof descriptor
             * @returns {OneOf} Created oneof
             * @throws {TypeError} If arguments are invalid
             */
            OneOf.fromJSON = function fromJSON(name, json) {
                return new OneOf(name, json.oneof, json.options);
            };

            /**
             * Converts this oneof to a oneof descriptor.
             * @returns {IOneOf} Oneof descriptor
             */
            OneOf.prototype.toJSON = function toJSON() {
                return util.toObject([
                    "options", this.options,
                    "oneof", this.oneof
                ]);
            };

            /**
             * Adds the fields of the specified oneof to the parent if not already done so.
             * @param {OneOf} oneof The oneof
             * @returns {undefined}
             * @inner
             * @ignore
             */
            function addFieldsToParent(oneof) {
                if (oneof.parent)
                    for (var i = 0; i < oneof.fieldsArray.length; ++i)
                        if (!oneof.fieldsArray[i].parent)
                            oneof.parent.add(oneof.fieldsArray[i]);
            }

            /**
             * Adds a field to this oneof and removes it from its current parent, if any.
             * @param {Field} field Field to add
             * @returns {OneOf} `this`
             */
            OneOf.prototype.add = function add(field) {

                /* istanbul ignore if */
                if (!(field instanceof Field))
                    throw TypeError("field must be a Field");

                if (field.parent && field.parent !== this.parent)
                    field.parent.remove(field);
                this.oneof.push(field.name);
                this.fieldsArray.push(field);
                field.partOf = this; // field.parent remains null
                addFieldsToParent(this);
                return this;
            };

            /**
             * Removes a field from this oneof and puts it back to the oneof's parent.
             * @param {Field} field Field to remove
             * @returns {OneOf} `this`
             */
            OneOf.prototype.remove = function remove(field) {

                /* istanbul ignore if */
                if (!(field instanceof Field))
                    throw TypeError("field must be a Field");

                var index = this.fieldsArray.indexOf(field);

                /* istanbul ignore if */
                if (index < 0)
                    throw Error(field + " is not a member of " + this);

                this.fieldsArray.splice(index, 1);
                index = this.oneof.indexOf(field.name);

                /* istanbul ignore else */
                if (index > -1) // theoretical
                    this.oneof.splice(index, 1);

                field.partOf = null;
                return this;
            };

            /**
             * @override
             */
            OneOf.prototype.onAdd = function onAdd(parent) {
                ReflectionObject.prototype.onAdd.call(this, parent);
                var self = this;
                // Collect present fields
                for (var i = 0; i < this.oneof.length; ++i) {
                    var field = parent.get(this.oneof[i]);
                    if (field && !field.partOf) {
                        field.partOf = self;
                        self.fieldsArray.push(field);
                    }
                }
                // Add not yet present fields
                addFieldsToParent(this);
            };

            /**
             * @override
             */
            OneOf.prototype.onRemove = function onRemove(parent) {
                for (var i = 0, field; i < this.fieldsArray.length; ++i)
                    if ((field = this.fieldsArray[i]).parent)
                        field.parent.remove(field);
                ReflectionObject.prototype.onRemove.call(this, parent);
            };

            /**
             * Decorator function as returned by {@link OneOf.d} (TypeScript).
             * @typedef OneOfDecorator
             * @type {function}
             * @param {Object} prototype Target prototype
             * @param {string} oneofName OneOf name
             * @returns {undefined}
             */

            /**
             * OneOf decorator (TypeScript).
             * @function
             * @param {...string} fieldNames Field names
             * @returns {OneOfDecorator} Decorator function
             * @template T extends string
             */
            OneOf.d = function decorateOneOf() {
                var fieldNames = new Array(arguments.length),
                    index = 0;
                while (index < arguments.length)
                    fieldNames[index] = arguments[index++];
                return function oneOfDecorator(prototype, oneofName) {
                    util.decorateType(prototype.constructor)
                        .add(new OneOf(oneofName, fieldNames));
                    Object.defineProperty(prototype, oneofName, {
                        get: util.oneOfGetter(fieldNames),
                        set: util.oneOfSetter(fieldNames)
                    });
                };
            };

        }, { "16": 16, "24": 24, "37": 37 }], 26: [function (require, module, exports) {
            "use strict";
            module.exports = parse;

            parse.filename = null;
            parse.defaults = { keepCase: false };

            var tokenize = require(34),
                Root = require(29),
                Type = require(35),
                Field = require(16),
                MapField = require(20),
                OneOf = require(25),
                Enum = require(15),
                Service = require(33),
                Method = require(22),
                types = require(36),
                util = require(37);

            var base10Re = /^[1-9][0-9]*$/,
                base10NegRe = /^-?[1-9][0-9]*$/,
                base16Re = /^0[x][0-9a-fA-F]+$/,
                base16NegRe = /^-?0[x][0-9a-fA-F]+$/,
                base8Re = /^0[0-7]+$/,
                base8NegRe = /^-?0[0-7]+$/,
                numberRe = /^(?![eE])[0-9]*(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?$/,
                nameRe = /^[a-zA-Z_][a-zA-Z_0-9]*$/,
                typeRefRe = /^(?:\.?[a-zA-Z_][a-zA-Z_0-9]*)+$/,
                fqTypeRefRe = /^(?:\.[a-zA-Z][a-zA-Z_0-9]*)+$/;

            /**
             * Result object returned from {@link parse}.
             * @interface IParserResult
             * @property {string|undefined} package Package name, if declared
             * @property {string[]|undefined} imports Imports, if any
             * @property {string[]|undefined} weakImports Weak imports, if any
             * @property {string|undefined} syntax Syntax, if specified (either `"proto2"` or `"proto3"`)
             * @property {Root} root Populated root instance
             */

            /**
             * Options modifying the behavior of {@link parse}.
             * @interface IParseOptions
             * @property {boolean} [keepCase=false] Keeps field casing instead of converting to camel case
             */

            /**
             * Parses the given .proto source and returns an object with the parsed contents.
             * @param {string} source Source contents
             * @param {Root} root Root to populate
             * @param {IParseOptions} [options] Parse options. Defaults to {@link parse.defaults} when omitted.
             * @returns {IParserResult} Parser result
             * @property {string} filename=null Currently processing file name for error reporting, if known
             * @property {IParseOptions} defaults Default {@link IParseOptions}
             */
            function parse(source, root, options) {
                /* eslint-disable callback-return */
                if (!(root instanceof Root)) {
                    options = root;
                    root = new Root();
                }
                if (!options)
                    options = parse.defaults;

                var tn = tokenize(source),
                    next = tn.next,
                    push = tn.push,
                    peek = tn.peek,
                    skip = tn.skip,
                    cmnt = tn.cmnt;

                var head = true,
                    pkg,
                    imports,
                    weakImports,
                    syntax,
                    isProto3 = false;

                var ptr = root;

                var applyCase = options.keepCase ? function (name) { return name; } : util.camelCase;

                /* istanbul ignore next */
                function illegal(token, name, insideTryCatch) {
                    var filename = parse.filename;
                    if (!insideTryCatch)
                        parse.filename = null;
                    return Error("illegal " + (name || "token") + " '" + token + "' (" + (filename ? filename + ", " : "") + "line " + tn.line + ")");
                }

                function readString() {
                    var values = [],
                        token;
                    do {
                        /* istanbul ignore if */
                        if ((token = next()) !== "\"" && token !== "'")
                            throw illegal(token);

                        values.push(next());
                        skip(token);
                        token = peek();
                    } while (token === "\"" || token === "'");
                    return values.join("");
                }

                function readValue(acceptTypeRef) {
                    var token = next();
                    switch (token) {
                        case "'":
                        case "\"":
                            push(token);
                            return readString();
                        case "true": case "TRUE":
                            return true;
                        case "false": case "FALSE":
                            return false;
                    }
                    try {
                        return parseNumber(token, /* insideTryCatch */ true);
                    } catch (e) {

                        /* istanbul ignore else */
                        if (acceptTypeRef && typeRefRe.test(token))
                            return token;

                        /* istanbul ignore next */
                        throw illegal(token, "value");
                    }
                }

                function readRanges(target, acceptStrings) {
                    var token, start;
                    do {
                        if (acceptStrings && ((token = peek()) === "\"" || token === "'"))
                            target.push(readString());
                        else
                            target.push([start = parseId(next()), skip("to", true) ? parseId(next()) : start]);
                    } while (skip(",", true));
                    skip(";");
                }

                function parseNumber(token, insideTryCatch) {
                    var sign = 1;
                    if (token.charAt(0) === "-") {
                        sign = -1;
                        token = token.substring(1);
                    }
                    switch (token) {
                        case "inf": case "INF": case "Inf":
                            return sign * Infinity;
                        case "nan": case "NAN": case "Nan": case "NaN":
                            return NaN;
                        case "0":
                            return 0;
                    }
                    if (base10Re.test(token))
                        return sign * parseInt(token, 10);
                    if (base16Re.test(token))
                        return sign * parseInt(token, 16);
                    if (base8Re.test(token))
                        return sign * parseInt(token, 8);

                    /* istanbul ignore else */
                    if (numberRe.test(token))
                        return sign * parseFloat(token);

                    /* istanbul ignore next */
                    throw illegal(token, "number", insideTryCatch);
                }

                function parseId(token, acceptNegative) {
                    switch (token) {
                        case "max": case "MAX": case "Max":
                            return 536870911;
                        case "0":
                            return 0;
                    }

                    /* istanbul ignore if */
                    if (!acceptNegative && token.charAt(0) === "-")
                        throw illegal(token, "id");

                    if (base10NegRe.test(token))
                        return parseInt(token, 10);
                    if (base16NegRe.test(token))
                        return parseInt(token, 16);

                    /* istanbul ignore else */
                    if (base8NegRe.test(token))
                        return parseInt(token, 8);

                    /* istanbul ignore next */
                    throw illegal(token, "id");
                }

                function parsePackage() {

                    /* istanbul ignore if */
                    if (pkg !== undefined)
                        throw illegal("package");

                    pkg = next();

                    /* istanbul ignore if */
                    if (!typeRefRe.test(pkg))
                        throw illegal(pkg, "name");

                    ptr = ptr.define(pkg);
                    skip(";");
                }

                function parseImport() {
                    var token = peek();
                    var whichImports;
                    switch (token) {
                        case "weak":
                            whichImports = weakImports || (weakImports = []);
                            next();
                            break;
                        case "public":
                            next();
                        // eslint-disable-line no-fallthrough
                        default:
                            whichImports = imports || (imports = []);
                            break;
                    }
                    token = readString();
                    skip(";");
                    whichImports.push(token);
                }

                function parseSyntax() {
                    skip("=");
                    syntax = readString();
                    isProto3 = syntax === "proto3";

                    /* istanbul ignore if */
                    if (!isProto3 && syntax !== "proto2")
                        throw illegal(syntax, "syntax");

                    skip(";");
                }

                function parseCommon(parent, token) {
                    switch (token) {

                        case "option":
                            parseOption(parent, token);
                            skip(";");
                            return true;

                        case "message":
                            parseType(parent, token);
                            return true;

                        case "enum":
                            parseEnum(parent, token);
                            return true;

                        case "service":
                            parseService(parent, token);
                            return true;

                        case "extend":
                            parseExtension(parent, token);
                            return true;
                    }
                    return false;
                }

                function ifBlock(obj, fnIf, fnElse) {
                    var trailingLine = tn.line;
                    if (obj) {
                        obj.comment = cmnt(); // try block-type comment
                        obj.filename = parse.filename;
                    }
                    if (skip("{", true)) {
                        var token;
                        while ((token = next()) !== "}")
                            fnIf(token);
                        skip(";", true);
                    } else {
                        if (fnElse)
                            fnElse();
                        skip(";");
                        if (obj && typeof obj.comment !== "string")
                            obj.comment = cmnt(trailingLine); // try line-type comment if no block
                    }
                }

                function parseType(parent, token) {

                    /* istanbul ignore if */
                    if (!nameRe.test(token = next()))
                        throw illegal(token, "type name");

                    var type = new Type(token);
                    ifBlock(type, function parseType_block(token) {
                        if (parseCommon(type, token))
                            return;

                        switch (token) {

                            case "map":
                                parseMapField(type, token);
                                break;

                            case "required":
                            case "optional":
                            case "repeated":
                                parseField(type, token);
                                break;

                            case "oneof":
                                parseOneOf(type, token);
                                break;

                            case "extensions":
                                readRanges(type.extensions || (type.extensions = []));
                                break;

                            case "reserved":
                                readRanges(type.reserved || (type.reserved = []), true);
                                break;

                            default:
                                /* istanbul ignore if */
                                if (!isProto3 || !typeRefRe.test(token))
                                    throw illegal(token);

                                push(token);
                                parseField(type, "optional");
                                break;
                        }
                    });
                    parent.add(type);
                }

                function parseField(parent, rule, extend) {
                    var type = next();
                    if (type === "group") {
                        parseGroup(parent, rule);
                        return;
                    }

                    /* istanbul ignore if */
                    if (!typeRefRe.test(type))
                        throw illegal(type, "type");

                    var name = next();

                    /* istanbul ignore if */
                    if (!nameRe.test(name))
                        throw illegal(name, "name");

                    name = applyCase(name);
                    skip("=");

                    var field = new Field(name, parseId(next()), type, rule, extend);
                    ifBlock(field, function parseField_block(token) {

                        /* istanbul ignore else */
                        if (token === "option") {
                            parseOption(field, token);
                            skip(";");
                        } else
                            throw illegal(token);

                    }, function parseField_line() {
                        parseInlineOptions(field);
                    });
                    parent.add(field);

                    // JSON defaults to packed=true if not set so we have to set packed=false explicity when
                    // parsing proto2 descriptors without the option, where applicable. This must be done for
                    // all known packable types and anything that could be an enum (= is not a basic type).
                    if (!isProto3 && field.repeated && (types.packed[type] !== undefined || types.basic[type] === undefined))
                        field.setOption("packed", false, /* ifNotSet */ true);
                }

                function parseGroup(parent, rule) {
                    var name = next();

                    /* istanbul ignore if */
                    if (!nameRe.test(name))
                        throw illegal(name, "name");

                    var fieldName = util.lcFirst(name);
                    if (name === fieldName)
                        name = util.ucFirst(name);
                    skip("=");
                    var id = parseId(next());
                    var type = new Type(name);
                    type.group = true;
                    var field = new Field(fieldName, id, name, rule);
                    field.filename = parse.filename;
                    ifBlock(type, function parseGroup_block(token) {
                        switch (token) {

                            case "option":
                                parseOption(type, token);
                                skip(";");
                                break;

                            case "required":
                            case "optional":
                            case "repeated":
                                parseField(type, token);
                                break;

                            /* istanbul ignore next */
                            default:
                                throw illegal(token); // there are no groups with proto3 semantics
                        }
                    });
                    parent.add(type)
                        .add(field);
                }

                function parseMapField(parent) {
                    skip("<");
                    var keyType = next();

                    /* istanbul ignore if */
                    if (types.mapKey[keyType] === undefined)
                        throw illegal(keyType, "type");

                    skip(",");
                    var valueType = next();

                    /* istanbul ignore if */
                    if (!typeRefRe.test(valueType))
                        throw illegal(valueType, "type");

                    skip(">");
                    var name = next();

                    /* istanbul ignore if */
                    if (!nameRe.test(name))
                        throw illegal(name, "name");

                    skip("=");
                    var field = new MapField(applyCase(name), parseId(next()), keyType, valueType);
                    ifBlock(field, function parseMapField_block(token) {

                        /* istanbul ignore else */
                        if (token === "option") {
                            parseOption(field, token);
                            skip(";");
                        } else
                            throw illegal(token);

                    }, function parseMapField_line() {
                        parseInlineOptions(field);
                    });
                    parent.add(field);
                }

                function parseOneOf(parent, token) {

                    /* istanbul ignore if */
                    if (!nameRe.test(token = next()))
                        throw illegal(token, "name");

                    var oneof = new OneOf(applyCase(token));
                    ifBlock(oneof, function parseOneOf_block(token) {
                        if (token === "option") {
                            parseOption(oneof, token);
                            skip(";");
                        } else {
                            push(token);
                            parseField(oneof, "optional");
                        }
                    });
                    parent.add(oneof);
                }

                function parseEnum(parent, token) {

                    /* istanbul ignore if */
                    if (!nameRe.test(token = next()))
                        throw illegal(token, "name");

                    var enm = new Enum(token);
                    ifBlock(enm, function parseEnum_block(token) {
                        switch (token) {
                            case "option":
                                parseOption(enm, token);
                                skip(";");
                                break;

                            case "reserved":
                                readRanges(enm.reserved || (enm.reserved = []), true);
                                break;

                            default:
                                parseEnumValue(enm, token);
                        }
                    });
                    parent.add(enm);
                }

                function parseEnumValue(parent, token) {

                    /* istanbul ignore if */
                    if (!nameRe.test(token))
                        throw illegal(token, "name");

                    skip("=");
                    var value = parseId(next(), true),
                        dummy = {};
                    ifBlock(dummy, function parseEnumValue_block(token) {

                        /* istanbul ignore else */
                        if (token === "option") {
                            parseOption(dummy, token); // skip
                            skip(";");
                        } else
                            throw illegal(token);

                    }, function parseEnumValue_line() {
                        parseInlineOptions(dummy); // skip
                    });
                    parent.add(token, value, dummy.comment);
                }

                function parseOption(parent, token) {
                    var isCustom = skip("(", true);

                    /* istanbul ignore if */
                    if (!typeRefRe.test(token = next()))
                        throw illegal(token, "name");

                    var name = token;
                    if (isCustom) {
                        skip(")");
                        name = "(" + name + ")";
                        token = peek();
                        if (fqTypeRefRe.test(token)) {
                            name += token;
                            next();
                        }
                    }
                    skip("=");
                    parseOptionValue(parent, name);
                }

                function parseOptionValue(parent, name) {
                    if (skip("{", true)) { // { a: "foo" b { c: "bar" } }
                        do {
                            /* istanbul ignore if */
                            if (!nameRe.test(token = next()))
                                throw illegal(token, "name");

                            if (peek() === "{")
                                parseOptionValue(parent, name + "." + token);
                            else {
                                skip(":");
                                if (peek() === "{")
                                    parseOptionValue(parent, name + "." + token);
                                else
                                    setOption(parent, name + "." + token, readValue(true));
                            }
                        } while (!skip("}", true));
                    } else
                        setOption(parent, name, readValue(true));
                    // Does not enforce a delimiter to be universal
                }

                function setOption(parent, name, value) {
                    if (parent.setOption)
                        parent.setOption(name, value);
                }

                function parseInlineOptions(parent) {
                    if (skip("[", true)) {
                        do {
                            parseOption(parent, "option");
                        } while (skip(",", true));
                        skip("]");
                    }
                    return parent;
                }

                function parseService(parent, token) {

                    /* istanbul ignore if */
                    if (!nameRe.test(token = next()))
                        throw illegal(token, "service name");

                    var service = new Service(token);
                    ifBlock(service, function parseService_block(token) {
                        if (parseCommon(service, token))
                            return;

                        /* istanbul ignore else */
                        if (token === "rpc")
                            parseMethod(service, token);
                        else
                            throw illegal(token);
                    });
                    parent.add(service);
                }

                function parseMethod(parent, token) {
                    var type = token;

                    /* istanbul ignore if */
                    if (!nameRe.test(token = next()))
                        throw illegal(token, "name");

                    var name = token,
                        requestType, requestStream,
                        responseType, responseStream;

                    skip("(");
                    if (skip("stream", true))
                        requestStream = true;

                    /* istanbul ignore if */
                    if (!typeRefRe.test(token = next()))
                        throw illegal(token);

                    requestType = token;
                    skip(")"); skip("returns"); skip("(");
                    if (skip("stream", true))
                        responseStream = true;

                    /* istanbul ignore if */
                    if (!typeRefRe.test(token = next()))
                        throw illegal(token);

                    responseType = token;
                    skip(")");

                    var method = new Method(name, type, requestType, responseType, requestStream, responseStream);
                    ifBlock(method, function parseMethod_block(token) {

                        /* istanbul ignore else */
                        if (token === "option") {
                            parseOption(method, token);
                            skip(";");
                        } else
                            throw illegal(token);

                    });
                    parent.add(method);
                }

                function parseExtension(parent, token) {

                    /* istanbul ignore if */
                    if (!typeRefRe.test(token = next()))
                        throw illegal(token, "reference");

                    var reference = token;
                    ifBlock(null, function parseExtension_block(token) {
                        switch (token) {

                            case "required":
                            case "repeated":
                            case "optional":
                                parseField(parent, token, reference);
                                break;

                            default:
                                /* istanbul ignore if */
                                if (!isProto3 || !typeRefRe.test(token))
                                    throw illegal(token);
                                push(token);
                                parseField(parent, "optional", reference);
                                break;
                        }
                    });
                }

                var token;
                while ((token = next()) !== null) {
                    switch (token) {

                        case "package":

                            /* istanbul ignore if */
                            if (!head)
                                throw illegal(token);

                            parsePackage();
                            break;

                        case "import":

                            /* istanbul ignore if */
                            if (!head)
                                throw illegal(token);

                            parseImport();
                            break;

                        case "syntax":

                            /* istanbul ignore if */
                            if (!head)
                                throw illegal(token);

                            parseSyntax();
                            break;

                        case "option":

                            /* istanbul ignore if */
                            if (!head)
                                throw illegal(token);

                            parseOption(ptr, token);
                            skip(";");
                            break;

                        default:

                            /* istanbul ignore else */
                            if (parseCommon(ptr, token)) {
                                head = false;
                                continue;
                            }

                            /* istanbul ignore next */
                            throw illegal(token);
                    }
                }

                parse.filename = null;
                return {
                    "package": pkg,
                    "imports": imports,
                    weakImports: weakImports,
                    syntax: syntax,
                    root: root
                };
            }

            /**
             * Parses the given .proto source and returns an object with the parsed contents.
             * @name parse
             * @function
             * @param {string} source Source contents
             * @param {IParseOptions} [options] Parse options. Defaults to {@link parse.defaults} when omitted.
             * @returns {IParserResult} Parser result
             * @property {string} filename=null Currently processing file name for error reporting, if known
             * @property {IParseOptions} defaults Default {@link IParseOptions}
             * @variation 2
             */

        }, { "15": 15, "16": 16, "20": 20, "22": 22, "25": 25, "29": 29, "33": 33, "34": 34, "35": 35, "36": 36, "37": 37 }], 27: [function (require, module, exports) {
            "use strict";
            module.exports = Reader;

            var util = require(39);

            var BufferReader; // cyclic

            var LongBits = util.LongBits,
                utf8 = util.utf8;

            /* istanbul ignore next */
            function indexOutOfRange(reader, writeLength) {
                return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
            }

            /**
             * Constructs a new reader instance using the specified buffer.
             * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.
             * @constructor
             * @param {Uint8Array} buffer Buffer to read from
             */
            function Reader(buffer) {

                /**
                 * Read buffer.
                 * @type {Uint8Array}
                 */
                this.buf = buffer;

                /**
                 * Read buffer position.
                 * @type {number}
                 */
                this.pos = 0;

                /**
                 * Read buffer length.
                 * @type {number}
                 */
                this.len = buffer.length;
            }

            var create_array = typeof Uint8Array !== "undefined"
                ? function create_typed_array(buffer) {
                    if (buffer instanceof Uint8Array || Array.isArray(buffer))
                        return new Reader(buffer);
                    throw Error("illegal buffer");
                }
                /* istanbul ignore next */
                : function create_array(buffer) {
                    if (Array.isArray(buffer))
                        return new Reader(buffer);
                    throw Error("illegal buffer");
                };

            /**
             * Creates a new reader using the specified buffer.
             * @function
             * @param {Uint8Array|Buffer} buffer Buffer to read from
             * @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}
             * @throws {Error} If `buffer` is not a valid buffer
             */
            Reader.create = util.Buffer
                ? function create_buffer_setup(buffer) {
                    return (Reader.create = function create_buffer(buffer) {
                        return util.Buffer.isBuffer(buffer)
                            ? new BufferReader(buffer)
                            /* istanbul ignore next */
                            : create_array(buffer);
                    })(buffer);
                }
                /* istanbul ignore next */
                : create_array;

            Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */ util.Array.prototype.slice;

            /**
             * Reads a varint as an unsigned 32 bit value.
             * @function
             * @returns {number} Value read
             */
            Reader.prototype.uint32 = (function read_uint32_setup() {
                var value = 4294967295; // optimizer type-hint, tends to deopt otherwise (?!)
                return function read_uint32() {
                    value = (this.buf[this.pos] & 127) >>> 0; if (this.buf[this.pos++] < 128) return value;
                    value = (value | (this.buf[this.pos] & 127) << 7) >>> 0; if (this.buf[this.pos++] < 128) return value;
                    value = (value | (this.buf[this.pos] & 127) << 14) >>> 0; if (this.buf[this.pos++] < 128) return value;
                    value = (value | (this.buf[this.pos] & 127) << 21) >>> 0; if (this.buf[this.pos++] < 128) return value;
                    value = (value | (this.buf[this.pos] & 15) << 28) >>> 0; if (this.buf[this.pos++] < 128) return value;

                    /* istanbul ignore if */
                    if ((this.pos += 5) > this.len) {
                        this.pos = this.len;
                        throw indexOutOfRange(this, 10);
                    }
                    return value;
                };
            })();

            /**
             * Reads a varint as a signed 32 bit value.
             * @returns {number} Value read
             */
            Reader.prototype.int32 = function read_int32() {
                return this.uint32() | 0;
            };

            /**
             * Reads a zig-zag encoded varint as a signed 32 bit value.
             * @returns {number} Value read
             */
            Reader.prototype.sint32 = function read_sint32() {
                var value = this.uint32();
                return value >>> 1 ^ -(value & 1) | 0;
            };

            /* eslint-disable no-invalid-this */

            function readLongVarint() {
                // tends to deopt with local vars for octet etc.
                var bits = new LongBits(0, 0);
                var i = 0;
                if (this.len - this.pos > 4) { // fast route (lo)
                    for (; i < 4; ++i) {
                        // 1st..4th
                        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
                        if (this.buf[this.pos++] < 128)
                            return bits;
                    }
                    // 5th
                    bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
                    bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
                    if (this.buf[this.pos++] < 128)
                        return bits;
                    i = 0;
                } else {
                    for (; i < 3; ++i) {
                        /* istanbul ignore if */
                        if (this.pos >= this.len)
                            throw indexOutOfRange(this);
                        // 1st..3th
                        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
                        if (this.buf[this.pos++] < 128)
                            return bits;
                    }
                    // 4th
                    bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
                    return bits;
                }
                if (this.len - this.pos > 4) { // fast route (hi)
                    for (; i < 5; ++i) {
                        // 6th..10th
                        bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
                        if (this.buf[this.pos++] < 128)
                            return bits;
                    }
                } else {
                    for (; i < 5; ++i) {
                        /* istanbul ignore if */
                        if (this.pos >= this.len)
                            throw indexOutOfRange(this);
                        // 6th..10th
                        bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
                        if (this.buf[this.pos++] < 128)
                            return bits;
                    }
                }
                /* istanbul ignore next */
                throw Error("invalid varint encoding");
            }

            /* eslint-enable no-invalid-this */

            /**
             * Reads a varint as a signed 64 bit value.
             * @name Reader#int64
             * @function
             * @returns {Long} Value read
             */

            /**
             * Reads a varint as an unsigned 64 bit value.
             * @name Reader#uint64
             * @function
             * @returns {Long} Value read
             */

            /**
             * Reads a zig-zag encoded varint as a signed 64 bit value.
             * @name Reader#sint64
             * @function
             * @returns {Long} Value read
             */

            /**
             * Reads a varint as a boolean.
             * @returns {boolean} Value read
             */
            Reader.prototype.bool = function read_bool() {
                return this.uint32() !== 0;
            };

            function readFixed32_end(buf, end) { // note that this uses `end`, not `pos`
                return (buf[end - 4]
                    | buf[end - 3] << 8
                    | buf[end - 2] << 16
                    | buf[end - 1] << 24) >>> 0;
            }

            /**
             * Reads fixed 32 bits as an unsigned 32 bit integer.
             * @returns {number} Value read
             */
            Reader.prototype.fixed32 = function read_fixed32() {

                /* istanbul ignore if */
                if (this.pos + 4 > this.len)
                    throw indexOutOfRange(this, 4);

                return readFixed32_end(this.buf, this.pos += 4);
            };

            /**
             * Reads fixed 32 bits as a signed 32 bit integer.
             * @returns {number} Value read
             */
            Reader.prototype.sfixed32 = function read_sfixed32() {

                /* istanbul ignore if */
                if (this.pos + 4 > this.len)
                    throw indexOutOfRange(this, 4);

                return readFixed32_end(this.buf, this.pos += 4) | 0;
            };

            /* eslint-disable no-invalid-this */

            function readFixed64(/* this: Reader */) {

                /* istanbul ignore if */
                if (this.pos + 8 > this.len)
                    throw indexOutOfRange(this, 8);

                return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
            }

            /* eslint-enable no-invalid-this */

            /**
             * Reads fixed 64 bits.
             * @name Reader#fixed64
             * @function
             * @returns {Long} Value read
             */

            /**
             * Reads zig-zag encoded fixed 64 bits.
             * @name Reader#sfixed64
             * @function
             * @returns {Long} Value read
             */

            /**
             * Reads a float (32 bit) as a number.
             * @function
             * @returns {number} Value read
             */
            Reader.prototype.float = function read_float() {

                /* istanbul ignore if */
                if (this.pos + 4 > this.len)
                    throw indexOutOfRange(this, 4);

                var value = util.float.readFloatLE(this.buf, this.pos);
                this.pos += 4;
                return value;
            };

            /**
             * Reads a double (64 bit float) as a number.
             * @function
             * @returns {number} Value read
             */
            Reader.prototype.double = function read_double() {

                /* istanbul ignore if */
                if (this.pos + 8 > this.len)
                    throw indexOutOfRange(this, 4);

                var value = util.float.readDoubleLE(this.buf, this.pos);
                this.pos += 8;
                return value;
            };

            /**
             * Reads a sequence of bytes preceeded by its length as a varint.
             * @returns {Uint8Array} Value read
             */
            Reader.prototype.bytes = function read_bytes() {
                var length = this.uint32(),
                    start = this.pos,
                    end = this.pos + length;

                /* istanbul ignore if */
                if (end > this.len)
                    throw indexOutOfRange(this, length);

                this.pos += length;
                if (Array.isArray(this.buf)) // plain array
                    return this.buf.slice(start, end);
                return start === end // fix for IE 10/Win8 and others' subarray returning array of size 1
                    ? new this.buf.constructor(0)
                    : this._slice.call(this.buf, start, end);
            };

            /**
             * Reads a string preceeded by its byte length as a varint.
             * @returns {string} Value read
             */
            Reader.prototype.string = function read_string() {
                var bytes = this.bytes();
                return utf8.read(bytes, 0, bytes.length);
            };

            /**
             * Skips the specified number of bytes if specified, otherwise skips a varint.
             * @param {number} [length] Length if known, otherwise a varint is assumed
             * @returns {Reader} `this`
             */
            Reader.prototype.skip = function skip(length) {
                if (typeof length === "number") {
                    /* istanbul ignore if */
                    if (this.pos + length > this.len)
                        throw indexOutOfRange(this, length);
                    this.pos += length;
                } else {
                    do {
                        /* istanbul ignore if */
                        if (this.pos >= this.len)
                            throw indexOutOfRange(this);
                    } while (this.buf[this.pos++] & 128);
                }
                return this;
            };

            /**
             * Skips the next element of the specified wire type.
             * @param {number} wireType Wire type received
             * @returns {Reader} `this`
             */
            Reader.prototype.skipType = function (wireType) {
                switch (wireType) {
                    case 0:
                        this.skip();
                        break;
                    case 1:
                        this.skip(8);
                        break;
                    case 2:
                        this.skip(this.uint32());
                        break;
                    case 3:
                        do { // eslint-disable-line no-constant-condition
                            if ((wireType = this.uint32() & 7) === 4)
                                break;
                            this.skipType(wireType);
                        } while (true);
                        break;
                    case 5:
                        this.skip(4);
                        break;

                    /* istanbul ignore next */
                    default:
                        throw Error("invalid wire type " + wireType + " at offset " + this.pos);
                }
                return this;
            };

            Reader._configure = function (BufferReader_) {
                BufferReader = BufferReader_;

                var fn = util.Long ? "toLong" : /* istanbul ignore next */ "toNumber";
                util.merge(Reader.prototype, {

                    int64: function read_int64() {
                        return readLongVarint.call(this) [fn](false);
                    },

                    uint64: function read_uint64() {
                        return readLongVarint.call(this) [fn](true);
                    },

                    sint64: function read_sint64() {
                        return readLongVarint.call(this).zzDecode() [fn](false);
                    },

                    fixed64: function read_fixed64() {
                        return readFixed64.call(this) [fn](true);
                    },

                    sfixed64: function read_sfixed64() {
                        return readFixed64.call(this) [fn](false);
                    }

                });
            };

        }, { "39": 39 }], 28: [function (require, module, exports) {
            "use strict";
            module.exports = BufferReader;

            // extends Reader
            var Reader = require(27);
            (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;

            var util = require(39);

            /**
             * Constructs a new buffer reader instance.
             * @classdesc Wire format reader using node buffers.
             * @extends Reader
             * @constructor
             * @param {Buffer} buffer Buffer to read from
             */
            function BufferReader(buffer) {
                Reader.call(this, buffer);

                /**
                 * Read buffer.
                 * @name BufferReader#buf
                 * @type {Buffer}
                 */
            }

            /* istanbul ignore else */
            if (util.Buffer)
                BufferReader.prototype._slice = util.Buffer.prototype.slice;

            /**
             * @override
             */
            BufferReader.prototype.string = function read_string_buffer() {
                var len = this.uint32(); // modifies pos
                return this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len));
            };

            /**
             * Reads a sequence of bytes preceeded by its length as a varint.
             * @name BufferReader#bytes
             * @function
             * @returns {Buffer} Value read
             */

        }, { "27": 27, "39": 39 }], 29: [function (require, module, exports) {
            "use strict";
            module.exports = Root;

            // extends Namespace
            var Namespace = require(23);
            ((Root.prototype = Object.create(Namespace.prototype)).constructor = Root).className = "Root";

            var Field = require(16),
                Enum = require(15),
                OneOf = require(25),
                util = require(37);

            var Type,   // cyclic
                parse,  // might be excluded
                common; // "

            /**
             * Constructs a new root namespace instance.
             * @classdesc Root namespace wrapping all types, enums, services, sub-namespaces etc. that belong together.
             * @extends NamespaceBase
             * @constructor
             * @param {Object.<string,*>} [options] Top level options
             */
            function Root(options) {
                Namespace.call(this, "", options);

                /**
                 * Deferred extension fields.
                 * @type {Field[]}
                 */
                this.deferred = [];

                /**
                 * Resolved file names of loaded files.
                 * @type {string[]}
                 */
                this.files = [];
            }

            /**
             * Loads a namespace descriptor into a root namespace.
             * @param {INamespace} json Nameespace descriptor
             * @param {Root} [root] Root namespace, defaults to create a new one if omitted
             * @returns {Root} Root namespace
             */
            Root.fromJSON = function fromJSON(json, root) {
                if (!root)
                    root = new Root();
                if (json.options)
                    root.setOptions(json.options);
                return root.addJSON(json.nested);
            };

            /**
             * Resolves the path of an imported file, relative to the importing origin.
             * This method exists so you can override it with your own logic in case your imports are scattered over multiple directories.
             * @function
             * @param {string} origin The file name of the importing file
             * @param {string} target The file name being imported
             * @returns {string|null} Resolved path to `target` or `null` to skip the file
             */
            Root.prototype.resolvePath = util.path.resolve;

            // A symbol-like function to safely signal synchronous loading
            /* istanbul ignore next */
            function SYNC() { } // eslint-disable-line no-empty-function

            /**
             * Loads one or multiple .proto or preprocessed .json files into this root namespace and calls the callback.
             * @param {string|string[]} filename Names of one or multiple files to load
             * @param {IParseOptions} options Parse options
             * @param {LoadCallback} callback Callback function
             * @returns {undefined}
             */
            Root.prototype.load = function load(filename, options, callback) {
                if (typeof options === "function") {
                    callback = options;
                    options = undefined;
                }
                var self = this;
                if (!callback)
                    return util.asPromise(load, self, filename, options);

                var sync = callback === SYNC; // undocumented

                // Finishes loading by calling the callback (exactly once)
                function finish(err, root) {
                    /* istanbul ignore if */
                    if (!callback)
                        return;
                    var cb = callback;
                    callback = null;
                    if (sync)
                        throw err;
                    cb(err, root);
                }

                // Processes a single file
                function process(filename, source) {
                    try {
                        if (util.isString(source) && source.charAt(0) === "{")
                            source = JSON.parse(source);
                        if (!util.isString(source))
                            self.setOptions(source.options).addJSON(source.nested);
                        else {
                            parse.filename = filename;
                            var parsed = parse(source, self, options),
                                resolved,
                                i = 0;
                            if (parsed.imports)
                                for (; i < parsed.imports.length; ++i)
                                    if (resolved = self.resolvePath(filename, parsed.imports[i]))
                                        fetch(resolved);
                            if (parsed.weakImports)
                                for (i = 0; i < parsed.weakImports.length; ++i)
                                    if (resolved = self.resolvePath(filename, parsed.weakImports[i]))
                                        fetch(resolved, true);
                        }
                    } catch (err) {
                        finish(err);
                    }
                    if (!sync && !queued)
                        finish(null, self); // only once anyway
                }

                // Fetches a single file
                function fetch(filename, weak) {

                    // Strip path if this file references a bundled definition
                    var idx = filename.lastIndexOf("google/protobuf/");
                    if (idx > -1) {
                        var altname = filename.substring(idx);
                        if (altname in common)
                            filename = altname;
                    }

                    // Skip if already loaded / attempted
                    if (self.files.indexOf(filename) > -1)
                        return;
                    self.files.push(filename);

                    // Shortcut bundled definitions
                    if (filename in common) {
                        if (sync)
                            process(filename, common[filename]);
                        else {
                            ++queued;
                            setTimeout(function () {
                                --queued;
                                process(filename, common[filename]);
                            });
                        }
                        return;
                    }

                    // Otherwise fetch from disk or network
                    if (sync) {
                        var source;
                        try {
                            source = util.fs.readFileSync(filename).toString("utf8");
                        } catch (err) {
                            if (!weak)
                                finish(err);
                            return;
                        }
                        process(filename, source);
                    } else {
                        ++queued;
                        util.fetch(filename, function (err, source) {
                            --queued;
                            /* istanbul ignore if */
                            if (!callback)
                                return; // terminated meanwhile
                            if (err) {
                                /* istanbul ignore else */
                                if (!weak)
                                    finish(err);
                                else if (!queued) // can't be covered reliably
                                    finish(null, self);
                                return;
                            }
                            process(filename, source);
                        });
                    }
                }
                var queued = 0;

                // Assembling the root namespace doesn't require working type
                // references anymore, so we can load everything in parallel
                if (util.isString(filename))
                    filename = [filename];
                for (var i = 0, resolved; i < filename.length; ++i)
                    if (resolved = self.resolvePath("", filename[i]))
                        fetch(resolved);

                if (sync)
                    return self;
                if (!queued)
                    finish(null, self);
                return undefined;
            };
            // function load(filename:string, options:IParseOptions, callback:LoadCallback):undefined

            /**
             * Loads one or multiple .proto or preprocessed .json files into this root namespace and calls the callback.
             * @function Root#load
             * @param {string|string[]} filename Names of one or multiple files to load
             * @param {LoadCallback} callback Callback function
             * @returns {undefined}
             * @variation 2
             */
            // function load(filename:string, callback:LoadCallback):undefined

            /**
             * Loads one or multiple .proto or preprocessed .json files into this root namespace and returns a promise.
             * @function Root#load
             * @param {string|string[]} filename Names of one or multiple files to load
             * @param {IParseOptions} [options] Parse options. Defaults to {@link parse.defaults} when omitted.
             * @returns {Promise<Root>} Promise
             * @variation 3
             */
            // function load(filename:string, [options:IParseOptions]):Promise<Root>

            /**
             * Synchronously loads one or multiple .proto or preprocessed .json files into this root namespace (node only).
             * @function Root#loadSync
             * @param {string|string[]} filename Names of one or multiple files to load
             * @param {IParseOptions} [options] Parse options. Defaults to {@link parse.defaults} when omitted.
             * @returns {Root} Root namespace
             * @throws {Error} If synchronous fetching is not supported (i.e. in browsers) or if a file's syntax is invalid
             */
            Root.prototype.loadSync = function loadSync(filename, options) {
                if (!util.isNode)
                    throw Error("not supported");
                return this.load(filename, options, SYNC);
            };

            /**
             * @override
             */
            Root.prototype.resolveAll = function resolveAll() {
                if (this.deferred.length)
                    throw Error("unresolvable extensions: " + this.deferred.map(function (field) {
                        return "'extend " + field.extend + "' in " + field.parent.fullName;
                    }).join(", "));
                return Namespace.prototype.resolveAll.call(this);
            };

            // only uppercased (and thus conflict-free) children are exposed, see below
            var exposeRe = /^[A-Z]/;

            /**
             * Handles a deferred declaring extension field by creating a sister field to represent it within its extended type.
             * @param {Root} root Root instance
             * @param {Field} field Declaring extension field witin the declaring type
             * @returns {boolean} `true` if successfully added to the extended type, `false` otherwise
             * @inner
             * @ignore
             */
            function tryHandleExtension(root, field) {
                var extendedType = field.parent.lookup(field.extend);
                if (extendedType) {
                    var sisterField = new Field(field.fullName, field.id, field.type, field.rule, undefined, field.options);
                    sisterField.declaringField = field;
                    field.extensionField = sisterField;
                    extendedType.add(sisterField);
                    return true;
                }
                return false;
            }

            /**
             * Called when any object is added to this root or its sub-namespaces.
             * @param {ReflectionObject} object Object added
             * @returns {undefined}
             * @private
             */
            Root.prototype._handleAdd = function _handleAdd(object) {
                if (object instanceof Field) {

                    if (/* an extension field (implies not part of a oneof) */ object.extend !== undefined && /* not already handled */ !object.extensionField)
                        if (!tryHandleExtension(this, object))
                            this.deferred.push(object);

                } else if (object instanceof Enum) {

                    if (exposeRe.test(object.name))
                        object.parent[object.name] = object.values; // expose enum values as property of its parent

                } else if (!(object instanceof OneOf)) /* everything else is a namespace */ {

                    if (object instanceof Type) // Try to handle any deferred extensions
                        for (var i = 0; i < this.deferred.length;)
                            if (tryHandleExtension(this, this.deferred[i]))
                                this.deferred.splice(i, 1);
                            else
                                ++i;
                    for (var j = 0; j < /* initializes */ object.nestedArray.length; ++j) // recurse into the namespace
                        this._handleAdd(object._nestedArray[j]);
                    if (exposeRe.test(object.name))
                        object.parent[object.name] = object; // expose namespace as property of its parent
                }

                // The above also adds uppercased (and thus conflict-free) nested types, services and enums as
                // properties of namespaces just like static code does. This allows using a .d.ts generated for
                // a static module with reflection-based solutions where the condition is met.
            };

            /**
             * Called when any object is removed from this root or its sub-namespaces.
             * @param {ReflectionObject} object Object removed
             * @returns {undefined}
             * @private
             */
            Root.prototype._handleRemove = function _handleRemove(object) {
                if (object instanceof Field) {

                    if (/* an extension field */ object.extend !== undefined) {
                        if (/* already handled */ object.extensionField) { // remove its sister field
                            object.extensionField.parent.remove(object.extensionField);
                            object.extensionField = null;
                        } else { // cancel the extension
                            var index = this.deferred.indexOf(object);
                            /* istanbul ignore else */
                            if (index > -1)
                                this.deferred.splice(index, 1);
                        }
                    }

                } else if (object instanceof Enum) {

                    if (exposeRe.test(object.name))
                        delete object.parent[object.name]; // unexpose enum values

                } else if (object instanceof Namespace) {

                    for (var i = 0; i < /* initializes */ object.nestedArray.length; ++i) // recurse into the namespace
                        this._handleRemove(object._nestedArray[i]);

                    if (exposeRe.test(object.name))
                        delete object.parent[object.name]; // unexpose namespaces

                }
            };

            Root._configure = function (Type_, parse_, common_) {
                Type = Type_;
                parse = parse_;
                common = common_;
            };

        }, { "15": 15, "16": 16, "23": 23, "25": 25, "37": 37 }], 30: [function (require, module, exports) {
            "use strict";
            module.exports = {};

            /**
             * Named roots.
             * This is where pbjs stores generated structures (the option `-r, --root` specifies a name).
             * Can also be used manually to make roots available accross modules.
             * @name roots
             * @type {Object.<string,Root>}
             * @example
             * // pbjs -r myroot -o compiled.js ...
             *
             * // in another module:
             * require("./compiled.js");
             *
             * // in any subsequent module:
             * var root = protobuf.roots["myroot"];
             */

        }, {}], 31: [function (require, module, exports) {
            "use strict";

            /**
             * Streaming RPC helpers.
             * @namespace
             */
            var rpc = exports;

            /**
             * RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.
             * @typedef RPCImpl
             * @type {function}
             * @param {Method|rpc.ServiceMethod<Message<{}>,Message<{}>>} method Reflected or static method being called
             * @param {Uint8Array} requestData Request data
             * @param {RPCImplCallback} callback Callback function
             * @returns {undefined}
             * @example
             * function rpcImpl(method, requestData, callback) {
             *     if (protobuf.util.lcFirst(method.name) !== "myMethod") // compatible with static code
             *         throw Error("no such method");
             *     asynchronouslyObtainAResponse(requestData, function(err, responseData) {
             *         callback(err, responseData);
             *     });
             * }
             */

            /**
             * Node-style callback as used by {@link RPCImpl}.
             * @typedef RPCImplCallback
             * @type {function}
             * @param {Error|null} error Error, if any, otherwise `null`
             * @param {Uint8Array|null} [response] Response data or `null` to signal end of stream, if there hasn't been an error
             * @returns {undefined}
             */

            rpc.Service = require(32);

        }, { "32": 32 }], 32: [function (require, module, exports) {
            "use strict";
            module.exports = Service;

            var util = require(39);

            // Extends EventEmitter
            (Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;

            /**
             * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
             *
             * Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.
             * @typedef rpc.ServiceMethodCallback
             * @template TRes extends Message<TRes>
             * @type {function}
             * @param {Error|null} error Error, if any
             * @param {TRes} [response] Response message
             * @returns {undefined}
             */

            /**
             * A service method part of a {@link rpc.Service} as created by {@link Service.create}.
             * @typedef rpc.ServiceMethod
             * @template TReq extends Message<TReq>
             * @template TRes extends Message<TRes>
             * @type {function}
             * @param {TReq|Properties<TReq>} request Request message or plain object
             * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message
             * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`
             */

            /**
             * Constructs a new RPC service instance.
             * @classdesc An RPC service as returned by {@link Service#create}.
             * @exports rpc.Service
             * @extends util.EventEmitter
             * @constructor
             * @param {RPCImpl} rpcImpl RPC implementation
             * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
             * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
             */
            function Service(rpcImpl, requestDelimited, responseDelimited) {

                if (typeof rpcImpl !== "function")
                    throw TypeError("rpcImpl must be a function");

                util.EventEmitter.call(this);

                /**
                 * RPC implementation. Becomes `null` once the service is ended.
                 * @type {RPCImpl|null}
                 */
                this.rpcImpl = rpcImpl;

                /**
                 * Whether requests are length-delimited.
                 * @type {boolean}
                 */
                this.requestDelimited = Boolean(requestDelimited);

                /**
                 * Whether responses are length-delimited.
                 * @type {boolean}
                 */
                this.responseDelimited = Boolean(responseDelimited);
            }

            /**
             * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.
             * @param {Method|rpc.ServiceMethod<TReq,TRes>} method Reflected or static method
             * @param {Constructor<TReq>} requestCtor Request constructor
             * @param {Constructor<TRes>} responseCtor Response constructor
             * @param {TReq|Properties<TReq>} request Request message or plain object
             * @param {rpc.ServiceMethodCallback<TRes>} callback Service callback
             * @returns {undefined}
             * @template TReq extends Message<TReq>
             * @template TRes extends Message<TRes>
             */
            Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {

                if (!request)
                    throw TypeError("request must be specified");

                var self = this;
                if (!callback)
                    return util.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);

                if (!self.rpcImpl) {
                    setTimeout(function () { callback(Error("already ended")); }, 0);
                    return undefined;
                }

                try {
                    return self.rpcImpl(
                        method,
                        requestCtor[self.requestDelimited ? "encodeDelimited" : "encode"](request).finish(),
                        function rpcCallback(err, response) {

                            if (err) {
                                self.emit("error", err, method);
                                return callback(err);
                            }

                            if (response === null) {
                                self.end(/* endedByRPC */ true);
                                return undefined;
                            }

                            if (!(response instanceof responseCtor)) {
                                try {
                                    response = responseCtor[self.responseDelimited ? "decodeDelimited" : "decode"](response);
                                } catch (err) {
                                    self.emit("error", err, method);
                                    return callback(err);
                                }
                            }

                            self.emit("data", response, method);
                            return callback(null, response);
                        }
                    );
                } catch (err) {
                    self.emit("error", err, method);
                    setTimeout(function () { callback(err); }, 0);
                    return undefined;
                }
            };

            /**
             * Ends this service and emits the `end` event.
             * @param {boolean} [endedByRPC=false] Whether the service has been ended by the RPC implementation.
             * @returns {rpc.Service} `this`
             */
            Service.prototype.end = function end(endedByRPC) {
                if (this.rpcImpl) {
                    if (!endedByRPC) // signal end to rpcImpl
                        this.rpcImpl(null, null, null);
                    this.rpcImpl = null;
                    this.emit("end").off();
                }
                return this;
            };

        }, { "39": 39 }], 33: [function (require, module, exports) {
            "use strict";
            module.exports = Service;

            // extends Namespace
            var Namespace = require(23);
            ((Service.prototype = Object.create(Namespace.prototype)).constructor = Service).className = "Service";

            var Method = require(22),
                util = require(37),
                rpc = require(31);

            /**
             * Constructs a new service instance.
             * @classdesc Reflected service.
             * @extends NamespaceBase
             * @constructor
             * @param {string} name Service name
             * @param {Object.<string,*>} [options] Service options
             * @throws {TypeError} If arguments are invalid
             */
            function Service(name, options) {
                Namespace.call(this, name, options);

                /**
                 * Service methods.
                 * @type {Object.<string,Method>}
                 */
                this.methods = {}; // toJSON, marker

                /**
                 * Cached methods as an array.
                 * @type {Method[]|null}
                 * @private
                 */
                this._methodsArray = null;
            }

            /**
             * Service descriptor.
             * @interface IService
             * @extends INamespace
             * @property {Object.<string,IMethod>} methods Method descriptors
             */

            /**
             * Constructs a service from a service descriptor.
             * @param {string} name Service name
             * @param {IService} json Service descriptor
             * @returns {Service} Created service
             * @throws {TypeError} If arguments are invalid
             */
            Service.fromJSON = function fromJSON(name, json) {
                var service = new Service(name, json.options);
                /* istanbul ignore else */
                if (json.methods)
                    for (var names = Object.keys(json.methods), i = 0; i < names.length; ++i)
                        service.add(Method.fromJSON(names[i], json.methods[names[i]]));
                if (json.nested)
                    service.addJSON(json.nested);
                return service;
            };

            /**
             * Converts this service to a service descriptor.
             * @returns {IService} Service descriptor
             */
            Service.prototype.toJSON = function toJSON() {
                var inherited = Namespace.prototype.toJSON.call(this);
                return util.toObject([
                    "options", inherited && inherited.options || undefined,
                    "methods", Namespace.arrayToJSON(this.methodsArray) || /* istanbul ignore next */ {},
                    "nested", inherited && inherited.nested || undefined
                ]);
            };

            /**
             * Methods of this service as an array for iteration.
             * @name Service#methodsArray
             * @type {Method[]}
             * @readonly
             */
            Object.defineProperty(Service.prototype, "methodsArray", {
                get: function () {
                    return this._methodsArray || (this._methodsArray = util.toArray(this.methods));
                }
            });

            function clearCache(service) {
                service._methodsArray = null;
                return service;
            }

            /**
             * @override
             */
            Service.prototype.get = function get(name) {
                return this.methods[name]
                    || Namespace.prototype.get.call(this, name);
            };

            /**
             * @override
             */
            Service.prototype.resolveAll = function resolveAll() {
                var methods = this.methodsArray;
                for (var i = 0; i < methods.length; ++i)
                    methods[i].resolve();
                return Namespace.prototype.resolve.call(this);
            };

            /**
             * @override
             */
            Service.prototype.add = function add(object) {

                /* istanbul ignore if */
                if (this.get(object.name))
                    throw Error("duplicate name '" + object.name + "' in " + this);

                if (object instanceof Method) {
                    this.methods[object.name] = object;
                    object.parent = this;
                    return clearCache(this);
                }
                return Namespace.prototype.add.call(this, object);
            };

            /**
             * @override
             */
            Service.prototype.remove = function remove(object) {
                if (object instanceof Method) {

                    /* istanbul ignore if */
                    if (this.methods[object.name] !== object)
                        throw Error(object + " is not a member of " + this);

                    delete this.methods[object.name];
                    object.parent = null;
                    return clearCache(this);
                }
                return Namespace.prototype.remove.call(this, object);
            };

            /**
             * Creates a runtime service using the specified rpc implementation.
             * @param {RPCImpl} rpcImpl RPC implementation
             * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
             * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
             * @returns {rpc.Service} RPC service. Useful where requests and/or responses are streamed.
             */
            Service.prototype.create = function create(rpcImpl, requestDelimited, responseDelimited) {
                var rpcService = new rpc.Service(rpcImpl, requestDelimited, responseDelimited);
                for (var i = 0, method; i < /* initializes */ this.methodsArray.length; ++i) {
                    var methodName = util.lcFirst((method = this._methodsArray[i]).resolve().name).replace(/[^$\w_]/g, "");
                    rpcService[methodName] = util.codegen(["r", "c"], util.isReserved(methodName) ? methodName + "_" : methodName)("return this.rpcCall(m,q,s,r,c)")({
                        m: method,
                        q: method.resolvedRequestType.ctor,
                        s: method.resolvedResponseType.ctor
                    });
                }
                return rpcService;
            };

        }, { "22": 22, "23": 23, "31": 31, "37": 37 }], 34: [function (require, module, exports) {
            "use strict";
            module.exports = tokenize;

            var delimRe = /[\s{}=;:[\],'"()<>]/g,
                stringDoubleRe = /(?:"([^"\\]*(?:\\.[^"\\]*)*)")/g,
                stringSingleRe = /(?:'([^'\\]*(?:\\.[^'\\]*)*)')/g;

            var setCommentRe = /^ *[*/]+ */,
                setCommentSplitRe = /\n/g,
                whitespaceRe = /\s/,
                unescapeRe = /\\(.?)/g;

            var unescapeMap = {
                "0": "\0",
                "r": "\r",
                "n": "\n",
                "t": "\t"
            };

            /**
             * Unescapes a string.
             * @param {string} str String to unescape
             * @returns {string} Unescaped string
             * @property {Object.<string,string>} map Special characters map
             * @memberof tokenize
             */
            function unescape(str) {
                return str.replace(unescapeRe, function ($0, $1) {
                    switch ($1) {
                        case "\\":
                        case "":
                            return $1;
                        default:
                            return unescapeMap[$1] || "";
                    }
                });
            }

            tokenize.unescape = unescape;

            /**
             * Gets the next token and advances.
             * @typedef TokenizerHandleNext
             * @type {function}
             * @returns {string|null} Next token or `null` on eof
             */

            /**
             * Peeks for the next token.
             * @typedef TokenizerHandlePeek
             * @type {function}
             * @returns {string|null} Next token or `null` on eof
             */

            /**
             * Pushes a token back to the stack.
             * @typedef TokenizerHandlePush
             * @type {function}
             * @param {string} token Token
             * @returns {undefined}
             */

            /**
             * Skips the next token.
             * @typedef TokenizerHandleSkip
             * @type {function}
             * @param {string} expected Expected token
             * @param {boolean} [optional=false] If optional
             * @returns {boolean} Whether the token matched
             * @throws {Error} If the token didn't match and is not optional
             */

            /**
             * Gets the comment on the previous line or, alternatively, the line comment on the specified line.
             * @typedef TokenizerHandleCmnt
             * @type {function}
             * @param {number} [line] Line number
             * @returns {string|null} Comment text or `null` if none
             */

            /**
             * Handle object returned from {@link tokenize}.
             * @interface ITokenizerHandle
             * @property {TokenizerHandleNext} next Gets the next token and advances (`null` on eof)
             * @property {TokenizerHandlePeek} peek Peeks for the next token (`null` on eof)
             * @property {TokenizerHandlePush} push Pushes a token back to the stack
             * @property {TokenizerHandleSkip} skip Skips a token, returns its presence and advances or, if non-optional and not present, throws
             * @property {TokenizerHandleCmnt} cmnt Gets the comment on the previous line or the line comment on the specified line, if any
             * @property {number} line Current line number
             */

            /**
             * Tokenizes the given .proto source and returns an object with useful utility functions.
             * @param {string} source Source contents
             * @returns {ITokenizerHandle} Tokenizer handle
             */
            function tokenize(source) {
                /* eslint-disable callback-return */
                source = source.toString();

                var offset = 0,
                    length = source.length,
                    line = 1,
                    commentType = null,
                    commentText = null,
                    commentLine = 0,
                    commentLineEmpty = false;

                var stack = [];

                var stringDelim = null;

                /* istanbul ignore next */
                /**
                 * Creates an error for illegal syntax.
                 * @param {string} subject Subject
                 * @returns {Error} Error created
                 * @inner
                 */
                function illegal(subject) {
                    return Error("illegal " + subject + " (line " + line + ")");
                }

                /**
                 * Reads a string till its end.
                 * @returns {string} String read
                 * @inner
                 */
                function readString() {
                    var re = stringDelim === "'" ? stringSingleRe : stringDoubleRe;
                    re.lastIndex = offset - 1;
                    var match = re.exec(source);
                    if (!match)
                        throw illegal("string");
                    offset = re.lastIndex;
                    push(stringDelim);
                    stringDelim = null;
                    return unescape(match[1]);
                }

                /**
                 * Gets the character at `pos` within the source.
                 * @param {number} pos Position
                 * @returns {string} Character
                 * @inner
                 */
                function charAt(pos) {
                    return source.charAt(pos);
                }

                /**
                 * Sets the current comment text.
                 * @param {number} start Start offset
                 * @param {number} end End offset
                 * @returns {undefined}
                 * @inner
                 */
                function setComment(start, end) {
                    commentType = source.charAt(start++);
                    commentLine = line;
                    commentLineEmpty = false;
                    var offset = start - 3, // "///" or "/**"
                        c;
                    do {
                        if (--offset < 0 || (c = source.charAt(offset)) === "\n") {
                            commentLineEmpty = true;
                            break;
                        }
                    } while (c === " " || c === "\t");
                    var lines = source
                        .substring(start, end)
                        .split(setCommentSplitRe);
                    for (var i = 0; i < lines.length; ++i)
                        lines[i] = lines[i].replace(setCommentRe, "").trim();
                    commentText = lines
                        .join("\n")
                        .trim();
                }

                /**
                 * Obtains the next token.
                 * @returns {string|null} Next token or `null` on eof
                 * @inner
                 */
                function next() {
                    if (stack.length > 0)
                        return stack.shift();
                    if (stringDelim)
                        return readString();
                    var repeat,
                        prev,
                        curr,
                        start,
                        isDoc;
                    do {
                        if (offset === length)
                            return null;
                        repeat = false;
                        while (whitespaceRe.test(curr = charAt(offset))) {
                            if (curr === "\n")
                                ++line;
                            if (++offset === length)
                                return null;
                        }
                        if (charAt(offset) === "/") {
                            if (++offset === length)
                                throw illegal("comment");
                            if (charAt(offset) === "/") { // Line
                                isDoc = charAt(start = offset + 1) === "/";
                                while (charAt(++offset) !== "\n")
                                    if (offset === length)
                                        return null;
                                ++offset;
                                if (isDoc) /// Comment
                                    setComment(start, offset - 1);
                                ++line;
                                repeat = true;
                            } else if ((curr = charAt(offset)) === "*") { /* Block */
                                isDoc = charAt(start = offset + 1) === "*";
                                do {
                                    if (curr === "\n")
                                        ++line;
                                    if (++offset === length)
                                        throw illegal("comment");
                                    prev = curr;
                                    curr = charAt(offset);
                                } while (prev !== "*" || curr !== "/");
                                ++offset;
                                if (isDoc) /** Comment */
                                    setComment(start, offset - 2);
                                repeat = true;
                            } else
                                return "/";
                        }
                    } while (repeat);

                    // offset !== length if we got here

                    var end = offset;
                    delimRe.lastIndex = 0;
                    var delim = delimRe.test(charAt(end++));
                    if (!delim)
                        while (end < length && !delimRe.test(charAt(end)))
                            ++end;
                    var token = source.substring(offset, offset = end);
                    if (token === "\"" || token === "'")
                        stringDelim = token;
                    return token;
                }

                /**
                 * Pushes a token back to the stack.
                 * @param {string} token Token
                 * @returns {undefined}
                 * @inner
                 */
                function push(token) {
                    stack.push(token);
                }

                /**
                 * Peeks for the next token.
                 * @returns {string|null} Token or `null` on eof
                 * @inner
                 */
                function peek() {
                    if (!stack.length) {
                        var token = next();
                        if (token === null)
                            return null;
                        push(token);
                    }
                    return stack[0];
                }

                /**
                 * Skips a token.
                 * @param {string} expected Expected token
                 * @param {boolean} [optional=false] Whether the token is optional
                 * @returns {boolean} `true` when skipped, `false` if not
                 * @throws {Error} When a required token is not present
                 * @inner
                 */
                function skip(expected, optional) {
                    var actual = peek(),
                        equals = actual === expected;
                    if (equals) {
                        next();
                        return true;
                    }
                    if (!optional)
                        throw illegal("token '" + actual + "', '" + expected + "' expected");
                    return false;
                }

                /**
                 * Gets a comment.
                 * @param {number} [trailingLine] Line number if looking for a trailing comment
                 * @returns {string|null} Comment text
                 * @inner
                 */
                function cmnt(trailingLine) {
                    var ret = null;
                    if (trailingLine === undefined) {
                        if (commentLine === line - 1 && (commentType === "*" || commentLineEmpty))
                            ret = commentText;
                    } else {
                        /* istanbul ignore else */
                        if (commentLine < trailingLine)
                            peek();
                        if (commentLine === trailingLine && !commentLineEmpty && commentType === "/")
                            ret = commentText;
                    }
                    return ret;
                }

                return Object.defineProperty({
                    next: next,
                    peek: peek,
                    push: push,
                    skip: skip,
                    cmnt: cmnt
                }, "line", {
                        get: function () { return line; }
                    });
                /* eslint-enable callback-return */
            }

        }, {}], 35: [function (require, module, exports) {
            "use strict";
            module.exports = Type;

            // extends Namespace
            var Namespace = require(23);
            ((Type.prototype = Object.create(Namespace.prototype)).constructor = Type).className = "Type";

            var Enum = require(15),
                OneOf = require(25),
                Field = require(16),
                MapField = require(20),
                Service = require(33),
                Message = require(21),
                Reader = require(27),
                Writer = require(42),
                util = require(37),
                encoder = require(14),
                decoder = require(13),
                verifier = require(40),
                converter = require(12),
                wrappers = require(41);

            /**
             * Constructs a new reflected message type instance.
             * @classdesc Reflected message type.
             * @extends NamespaceBase
             * @constructor
             * @param {string} name Message name
             * @param {Object.<string,*>} [options] Declared options
             */
            function Type(name, options) {
                Namespace.call(this, name, options);

                /**
                 * Message fields.
                 * @type {Object.<string,Field>}
                 */
                this.fields = {};  // toJSON, marker

                /**
                 * Oneofs declared within this namespace, if any.
                 * @type {Object.<string,OneOf>}
                 */
                this.oneofs = undefined; // toJSON

                /**
                 * Extension ranges, if any.
                 * @type {number[][]}
                 */
                this.extensions = undefined; // toJSON

                /**
                 * Reserved ranges, if any.
                 * @type {Array.<number[]|string>}
                 */
                this.reserved = undefined; // toJSON

                /*?
                 * Whether this type is a legacy group.
                 * @type {boolean|undefined}
                 */
                this.group = undefined; // toJSON

                /**
                 * Cached fields by id.
                 * @type {Object.<number,Field>|null}
                 * @private
                 */
                this._fieldsById = null;

                /**
                 * Cached fields as an array.
                 * @type {Field[]|null}
                 * @private
                 */
                this._fieldsArray = null;

                /**
                 * Cached oneofs as an array.
                 * @type {OneOf[]|null}
                 * @private
                 */
                this._oneofsArray = null;

                /**
                 * Cached constructor.
                 * @type {Constructor<{}>}
                 * @private
                 */
                this._ctor = null;
            }

            Object.defineProperties(Type.prototype, {

                /**
                 * Message fields by id.
                 * @name Type#fieldsById
                 * @type {Object.<number,Field>}
                 * @readonly
                 */
                fieldsById: {
                    get: function () {

                        /* istanbul ignore if */
                        if (this._fieldsById)
                            return this._fieldsById;

                        this._fieldsById = {};
                        for (var names = Object.keys(this.fields), i = 0; i < names.length; ++i) {
                            var field = this.fields[names[i]],
                                id = field.id;

                            /* istanbul ignore if */
                            if (this._fieldsById[id])
                                throw Error("duplicate id " + id + " in " + this);

                            this._fieldsById[id] = field;
                        }
                        return this._fieldsById;
                    }
                },

                /**
                 * Fields of this message as an array for iteration.
                 * @name Type#fieldsArray
                 * @type {Field[]}
                 * @readonly
                 */
                fieldsArray: {
                    get: function () {
                        return this._fieldsArray || (this._fieldsArray = util.toArray(this.fields));
                    }
                },

                /**
                 * Oneofs of this message as an array for iteration.
                 * @name Type#oneofsArray
                 * @type {OneOf[]}
                 * @readonly
                 */
                oneofsArray: {
                    get: function () {
                        return this._oneofsArray || (this._oneofsArray = util.toArray(this.oneofs));
                    }
                },

                /**
                 * The registered constructor, if any registered, otherwise a generic constructor.
                 * Assigning a function replaces the internal constructor. If the function does not extend {@link Message} yet, its prototype will be setup accordingly and static methods will be populated. If it already extends {@link Message}, it will just replace the internal constructor.
                 * @name Type#ctor
                 * @type {Constructor<{}>}
                 */
                ctor: {
                    get: function () {
                        return this._ctor || (this.ctor = Type.generateConstructor(this)());
                    },
                    set: function (ctor) {

                        // Ensure proper prototype
                        var prototype = ctor.prototype;
                        if (!(prototype instanceof Message)) {
                            (ctor.prototype = new Message()).constructor = ctor;
                            util.merge(ctor.prototype, prototype);
                        }

                        // Classes and messages reference their reflected type
                        ctor.$type = ctor.prototype.$type = this;

                        // Mix in static methods
                        util.merge(ctor, Message, true);

                        this._ctor = ctor;

                        // Messages have non-enumerable default values on their prototype
                        var i = 0;
                        for (; i < /* initializes */ this.fieldsArray.length; ++i)
                            this._fieldsArray[i].resolve(); // ensures a proper value

                        // Messages have non-enumerable getters and setters for each virtual oneof field
                        var ctorProperties = {};
                        for (i = 0; i < /* initializes */ this.oneofsArray.length; ++i)
                            ctorProperties[this._oneofsArray[i].resolve().name] = {
                                get: util.oneOfGetter(this._oneofsArray[i].oneof),
                                set: util.oneOfSetter(this._oneofsArray[i].oneof)
                            };
                        if (i)
                            Object.defineProperties(ctor.prototype, ctorProperties);
                    }
                }
            });

            /**
             * Generates a constructor function for the specified type.
             * @param {Type} mtype Message type
             * @returns {Codegen} Codegen instance
             */
            Type.generateConstructor = function generateConstructor(mtype) {
                /* eslint-disable no-unexpected-multiline */
                var gen = util.codegen(["p"], mtype.name);
                // explicitly initialize mutable object/array fields so that these aren't just inherited from the prototype
                for (var i = 0, field; i < mtype.fieldsArray.length; ++i)
                    if ((field = mtype._fieldsArray[i]).map) gen
                        ("this%s={}", util.safeProp(field.name));
                    else if (field.repeated) gen
                        ("this%s=[]", util.safeProp(field.name));
                return gen
                    ("if(p)for(var ks=Object.keys(p),i=0;i<ks.length;++i)if(p[ks[i]]!=null)") // omit undefined or null
                    ("this[ks[i]]=p[ks[i]]");
                /* eslint-enable no-unexpected-multiline */
            };

            function clearCache(type) {
                type._fieldsById = type._fieldsArray = type._oneofsArray = null;
                delete type.encode;
                delete type.decode;
                delete type.verify;
                return type;
            }

            /**
             * Message type descriptor.
             * @interface IType
             * @extends INamespace
             * @property {Object.<string,IOneOf>} [oneofs] Oneof descriptors
             * @property {Object.<string,IField>} fields Field descriptors
             * @property {number[][]} [extensions] Extension ranges
             * @property {number[][]} [reserved] Reserved ranges
             * @property {boolean} [group=false] Whether a legacy group or not
             */

            /**
             * Creates a message type from a message type descriptor.
             * @param {string} name Message name
             * @param {IType} json Message type descriptor
             * @returns {Type} Created message type
             */
            Type.fromJSON = function fromJSON(name, json) {
                var type = new Type(name, json.options);
                type.extensions = json.extensions;
                type.reserved = json.reserved;
                var names = Object.keys(json.fields),
                    i = 0;
                for (; i < names.length; ++i)
                    type.add(
                        (typeof json.fields[names[i]].keyType !== "undefined"
                            ? MapField.fromJSON
                            : Field.fromJSON)(names[i], json.fields[names[i]])
                    );
                if (json.oneofs)
                    for (names = Object.keys(json.oneofs), i = 0; i < names.length; ++i)
                        type.add(OneOf.fromJSON(names[i], json.oneofs[names[i]]));
                if (json.nested)
                    for (names = Object.keys(json.nested), i = 0; i < names.length; ++i) {
                        var nested = json.nested[names[i]];
                        type.add( // most to least likely
                            (nested.id !== undefined
                                ? Field.fromJSON
                                : nested.fields !== undefined
                                    ? Type.fromJSON
                                    : nested.values !== undefined
                                        ? Enum.fromJSON
                                        : nested.methods !== undefined
                                            ? Service.fromJSON
                                            : Namespace.fromJSON)(names[i], nested)
                        );
                    }
                if (json.extensions && json.extensions.length)
                    type.extensions = json.extensions;
                if (json.reserved && json.reserved.length)
                    type.reserved = json.reserved;
                if (json.group)
                    type.group = true;
                return type;
            };

            /**
             * Converts this message type to a message type descriptor.
             * @returns {IType} Message type descriptor
             */
            Type.prototype.toJSON = function toJSON() {
                var inherited = Namespace.prototype.toJSON.call(this);
                return util.toObject([
                    "options", inherited && inherited.options || undefined,
                    "oneofs", Namespace.arrayToJSON(this.oneofsArray),
                    "fields", Namespace.arrayToJSON(this.fieldsArray.filter(function (obj) { return !obj.declaringField; })) || {},
                    "extensions", this.extensions && this.extensions.length ? this.extensions : undefined,
                    "reserved", this.reserved && this.reserved.length ? this.reserved : undefined,
                    "group", this.group || undefined,
                    "nested", inherited && inherited.nested || undefined
                ]);
            };

            /**
             * @override
             */
            Type.prototype.resolveAll = function resolveAll() {
                var fields = this.fieldsArray, i = 0;
                while (i < fields.length)
                    fields[i++].resolve();
                var oneofs = this.oneofsArray; i = 0;
                while (i < oneofs.length)
                    oneofs[i++].resolve();
                return Namespace.prototype.resolveAll.call(this);
            };

            /**
             * @override
             */
            Type.prototype.get = function get(name) {
                return this.fields[name]
                    || this.oneofs && this.oneofs[name]
                    || this.nested && this.nested[name]
                    || null;
            };

            /**
             * Adds a nested object to this type.
             * @param {ReflectionObject} object Nested object to add
             * @returns {Type} `this`
             * @throws {TypeError} If arguments are invalid
             * @throws {Error} If there is already a nested object with this name or, if a field, when there is already a field with this id
             */
            Type.prototype.add = function add(object) {

                if (this.get(object.name))
                    throw Error("duplicate name '" + object.name + "' in " + this);

                if (object instanceof Field && object.extend === undefined) {
                    // NOTE: Extension fields aren't actual fields on the declaring type, but nested objects.
                    // The root object takes care of adding distinct sister-fields to the respective extended
                    // type instead.

                    // avoids calling the getter if not absolutely necessary because it's called quite frequently
                    if (this._fieldsById ? /* istanbul ignore next */ this._fieldsById[object.id] : this.fieldsById[object.id])
                        throw Error("duplicate id " + object.id + " in " + this);
                    if (this.isReservedId(object.id))
                        throw Error("id " + object.id + " is reserved in " + this);
                    if (this.isReservedName(object.name))
                        throw Error("name '" + object.name + "' is reserved in " + this);

                    if (object.parent)
                        object.parent.remove(object);
                    this.fields[object.name] = object;
                    object.message = this;
                    object.onAdd(this);
                    return clearCache(this);
                }
                if (object instanceof OneOf) {
                    if (!this.oneofs)
                        this.oneofs = {};
                    this.oneofs[object.name] = object;
                    object.onAdd(this);
                    return clearCache(this);
                }
                return Namespace.prototype.add.call(this, object);
            };

            /**
             * Removes a nested object from this type.
             * @param {ReflectionObject} object Nested object to remove
             * @returns {Type} `this`
             * @throws {TypeError} If arguments are invalid
             * @throws {Error} If `object` is not a member of this type
             */
            Type.prototype.remove = function remove(object) {
                if (object instanceof Field && object.extend === undefined) {
                    // See Type#add for the reason why extension fields are excluded here.

                    /* istanbul ignore if */
                    if (!this.fields || this.fields[object.name] !== object)
                        throw Error(object + " is not a member of " + this);

                    delete this.fields[object.name];
                    object.parent = null;
                    object.onRemove(this);
                    return clearCache(this);
                }
                if (object instanceof OneOf) {

                    /* istanbul ignore if */
                    if (!this.oneofs || this.oneofs[object.name] !== object)
                        throw Error(object + " is not a member of " + this);

                    delete this.oneofs[object.name];
                    object.parent = null;
                    object.onRemove(this);
                    return clearCache(this);
                }
                return Namespace.prototype.remove.call(this, object);
            };

            /**
             * Tests if the specified id is reserved.
             * @param {number} id Id to test
             * @returns {boolean} `true` if reserved, otherwise `false`
             */
            Type.prototype.isReservedId = function isReservedId(id) {
                return Namespace.isReservedId(this.reserved, id);
            };

            /**
             * Tests if the specified name is reserved.
             * @param {string} name Name to test
             * @returns {boolean} `true` if reserved, otherwise `false`
             */
            Type.prototype.isReservedName = function isReservedName(name) {
                return Namespace.isReservedName(this.reserved, name);
            };

            /**
             * Creates a new message of this type using the specified properties.
             * @param {Object.<string,*>} [properties] Properties to set
             * @returns {Message<{}>} Message instance
             */
            Type.prototype.create = function create(properties) {
                return new this.ctor(properties);
            };

            /**
             * Sets up {@link Type#encode|encode}, {@link Type#decode|decode} and {@link Type#verify|verify}.
             * @returns {Type} `this`
             */
            Type.prototype.setup = function setup() {
                // Sets up everything at once so that the prototype chain does not have to be re-evaluated
                // multiple times (V8, soft-deopt prototype-check).

                var fullName = this.fullName,
                    types = [];
                for (var i = 0; i < /* initializes */ this.fieldsArray.length; ++i)
                    types.push(this._fieldsArray[i].resolve().resolvedType);

                // Replace setup methods with type-specific generated functions
                this.encode = encoder(this)({
                    Writer: Writer,
                    types: types,
                    util: util
                });
                this.decode = decoder(this)({
                    Reader: Reader,
                    types: types,
                    util: util
                });
                this.verify = verifier(this)({
                    types: types,
                    util: util
                });
                this.fromObject = converter.fromObject(this)({
                    types: types,
                    util: util
                });
                this.toObject = converter.toObject(this)({
                    types: types,
                    util: util
                });

                // Inject custom wrappers for common types
                var wrapper = wrappers[fullName];
                if (wrapper) {
                    var originalThis = Object.create(this);
                    // if (wrapper.fromObject) {
                    originalThis.fromObject = this.fromObject;
                    this.fromObject = wrapper.fromObject.bind(originalThis);
                    // }
                    // if (wrapper.toObject) {
                    originalThis.toObject = this.toObject;
                    this.toObject = wrapper.toObject.bind(originalThis);
                    // }
                }

                return this;
            };

            /**
             * Encodes a message of this type. Does not implicitly {@link Type#verify|verify} messages.
             * @param {Message<{}>|Object.<string,*>} message Message instance or plain object
             * @param {Writer} [writer] Writer to encode to
             * @returns {Writer} writer
             */
            Type.prototype.encode = function encode_setup(message, writer) {
                return this.setup().encode(message, writer); // overrides this method
            };

            /**
             * Encodes a message of this type preceeded by its byte length as a varint. Does not implicitly {@link Type#verify|verify} messages.
             * @param {Message<{}>|Object.<string,*>} message Message instance or plain object
             * @param {Writer} [writer] Writer to encode to
             * @returns {Writer} writer
             */
            Type.prototype.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer && writer.len ? writer.fork() : writer).ldelim();
            };

            /**
             * Decodes a message of this type.
             * @param {Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Length of the message, if known beforehand
             * @returns {Message<{}>} Decoded message
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {util.ProtocolError<{}>} If required fields are missing
             */
            Type.prototype.decode = function decode_setup(reader, length) {
                return this.setup().decode(reader, length); // overrides this method
            };

            /**
             * Decodes a message of this type preceeded by its byte length as a varint.
             * @param {Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {Message<{}>} Decoded message
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {util.ProtocolError} If required fields are missing
             */
            Type.prototype.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof Reader))
                    reader = Reader.create(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies that field values are valid and that required fields are present.
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {null|string} `null` if valid, otherwise the reason why it is not
             */
            Type.prototype.verify = function verify_setup(message) {
                return this.setup().verify(message); // overrides this method
            };

            /**
             * Creates a new message of this type from a plain object. Also converts values to their respective internal types.
             * @param {Object.<string,*>} object Plain object to convert
             * @returns {Message<{}>} Message instance
             */
            Type.prototype.fromObject = function fromObject(object) {
                return this.setup().fromObject(object);
            };

            /**
             * Conversion options as used by {@link Type#toObject} and {@link Message.toObject}.
             * @interface IConversionOptions
             * @property {Function} [longs] Long conversion type.
             * Valid values are `String` and `Number` (the global types).
             * Defaults to copy the present value, which is a possibly unsafe number without and a {@link Long} with a long library.
             * @property {Function} [enums] Enum value conversion type.
             * Only valid value is `String` (the global type).
             * Defaults to copy the present value, which is the numeric id.
             * @property {Function} [bytes] Bytes value conversion type.
             * Valid values are `Array` and (a base64 encoded) `String` (the global types).
             * Defaults to copy the present value, which usually is a Buffer under node and an Uint8Array in the browser.
             * @property {boolean} [defaults=false] Also sets default values on the resulting object
             * @property {boolean} [arrays=false] Sets empty arrays for missing repeated fields even if `defaults=false`
             * @property {boolean} [objects=false] Sets empty objects for missing map fields even if `defaults=false`
             * @property {boolean} [oneofs=false] Includes virtual oneof properties set to the present field's name, if any
             * @property {boolean} [json=false] Performs additional JSON compatibility conversions, i.e. NaN and Infinity to strings
             */

            /**
             * Creates a plain object from a message of this type. Also converts values to other types if specified.
             * @param {Message<{}>} message Message instance
             * @param {IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            Type.prototype.toObject = function toObject(message, options) {
                return this.setup().toObject(message, options);
            };

            /**
             * Decorator function as returned by {@link Type.d} (TypeScript).
             * @typedef TypeDecorator
             * @type {function}
             * @param {Constructor<T>} target Target constructor
             * @returns {undefined}
             * @template T extends Message<T>
             */

            /**
             * Type decorator (TypeScript).
             * @param {string} [typeName] Type name, defaults to the constructor's name
             * @returns {TypeDecorator<T>} Decorator function
             * @template T extends Message<T>
             */
            Type.d = function decorateType(typeName) {
                return function typeDecorator(target) {
                    util.decorateType(target, typeName);
                };
            };

        }, { "12": 12, "13": 13, "14": 14, "15": 15, "16": 16, "20": 20, "21": 21, "23": 23, "25": 25, "27": 27, "33": 33, "37": 37, "40": 40, "41": 41, "42": 42 }], 36: [function (require, module, exports) {
            "use strict";

            /**
             * Common type constants.
             * @namespace
             */
            var types = exports;

            var util = require(37);

            var s = [
                "double",   // 0
                "float",    // 1
                "int32",    // 2
                "uint32",   // 3
                "sint32",   // 4
                "fixed32",  // 5
                "sfixed32", // 6
                "int64",    // 7
                "uint64",   // 8
                "sint64",   // 9
                "fixed64",  // 10
                "sfixed64", // 11
                "bool",     // 12
                "string",   // 13
                "bytes"     // 14
            ];

            function bake(values, offset) {
                var i = 0, o = {};
                offset |= 0;
                while (i < values.length) o[s[i + offset]] = values[i++];
                return o;
            }

            /**
             * Basic type wire types.
             * @type {Object.<string,number>}
             * @const
             * @property {number} double=1 Fixed64 wire type
             * @property {number} float=5 Fixed32 wire type
             * @property {number} int32=0 Varint wire type
             * @property {number} uint32=0 Varint wire type
             * @property {number} sint32=0 Varint wire type
             * @property {number} fixed32=5 Fixed32 wire type
             * @property {number} sfixed32=5 Fixed32 wire type
             * @property {number} int64=0 Varint wire type
             * @property {number} uint64=0 Varint wire type
             * @property {number} sint64=0 Varint wire type
             * @property {number} fixed64=1 Fixed64 wire type
             * @property {number} sfixed64=1 Fixed64 wire type
             * @property {number} bool=0 Varint wire type
             * @property {number} string=2 Ldelim wire type
             * @property {number} bytes=2 Ldelim wire type
             */
            types.basic = bake([
    /* double   */ 1,
    /* float    */ 5,
    /* int32    */ 0,
    /* uint32   */ 0,
    /* sint32   */ 0,
    /* fixed32  */ 5,
    /* sfixed32 */ 5,
    /* int64    */ 0,
    /* uint64   */ 0,
    /* sint64   */ 0,
    /* fixed64  */ 1,
    /* sfixed64 */ 1,
    /* bool     */ 0,
    /* string   */ 2,
    /* bytes    */ 2
            ]);

            /**
             * Basic type defaults.
             * @type {Object.<string,*>}
             * @const
             * @property {number} double=0 Double default
             * @property {number} float=0 Float default
             * @property {number} int32=0 Int32 default
             * @property {number} uint32=0 Uint32 default
             * @property {number} sint32=0 Sint32 default
             * @property {number} fixed32=0 Fixed32 default
             * @property {number} sfixed32=0 Sfixed32 default
             * @property {number} int64=0 Int64 default
             * @property {number} uint64=0 Uint64 default
             * @property {number} sint64=0 Sint32 default
             * @property {number} fixed64=0 Fixed64 default
             * @property {number} sfixed64=0 Sfixed64 default
             * @property {boolean} bool=false Bool default
             * @property {string} string="" String default
             * @property {Array.<number>} bytes=Array(0) Bytes default
             * @property {null} message=null Message default
             */
            types.defaults = bake([
    /* double   */ 0,
    /* float    */ 0,
    /* int32    */ 0,
    /* uint32   */ 0,
    /* sint32   */ 0,
    /* fixed32  */ 0,
    /* sfixed32 */ 0,
    /* int64    */ 0,
    /* uint64   */ 0,
    /* sint64   */ 0,
    /* fixed64  */ 0,
    /* sfixed64 */ 0,
    /* bool     */ false,
    /* string   */ "",
    /* bytes    */ util.emptyArray,
    /* message  */ null
            ]);

            /**
             * Basic long type wire types.
             * @type {Object.<string,number>}
             * @const
             * @property {number} int64=0 Varint wire type
             * @property {number} uint64=0 Varint wire type
             * @property {number} sint64=0 Varint wire type
             * @property {number} fixed64=1 Fixed64 wire type
             * @property {number} sfixed64=1 Fixed64 wire type
             */
            types.long = bake([
    /* int64    */ 0,
    /* uint64   */ 0,
    /* sint64   */ 0,
    /* fixed64  */ 1,
    /* sfixed64 */ 1
            ], 7);

            /**
             * Allowed types for map keys with their associated wire type.
             * @type {Object.<string,number>}
             * @const
             * @property {number} int32=0 Varint wire type
             * @property {number} uint32=0 Varint wire type
             * @property {number} sint32=0 Varint wire type
             * @property {number} fixed32=5 Fixed32 wire type
             * @property {number} sfixed32=5 Fixed32 wire type
             * @property {number} int64=0 Varint wire type
             * @property {number} uint64=0 Varint wire type
             * @property {number} sint64=0 Varint wire type
             * @property {number} fixed64=1 Fixed64 wire type
             * @property {number} sfixed64=1 Fixed64 wire type
             * @property {number} bool=0 Varint wire type
             * @property {number} string=2 Ldelim wire type
             */
            types.mapKey = bake([
    /* int32    */ 0,
    /* uint32   */ 0,
    /* sint32   */ 0,
    /* fixed32  */ 5,
    /* sfixed32 */ 5,
    /* int64    */ 0,
    /* uint64   */ 0,
    /* sint64   */ 0,
    /* fixed64  */ 1,
    /* sfixed64 */ 1,
    /* bool     */ 0,
    /* string   */ 2
            ], 2);

            /**
             * Allowed types for packed repeated fields with their associated wire type.
             * @type {Object.<string,number>}
             * @const
             * @property {number} double=1 Fixed64 wire type
             * @property {number} float=5 Fixed32 wire type
             * @property {number} int32=0 Varint wire type
             * @property {number} uint32=0 Varint wire type
             * @property {number} sint32=0 Varint wire type
             * @property {number} fixed32=5 Fixed32 wire type
             * @property {number} sfixed32=5 Fixed32 wire type
             * @property {number} int64=0 Varint wire type
             * @property {number} uint64=0 Varint wire type
             * @property {number} sint64=0 Varint wire type
             * @property {number} fixed64=1 Fixed64 wire type
             * @property {number} sfixed64=1 Fixed64 wire type
             * @property {number} bool=0 Varint wire type
             */
            types.packed = bake([
    /* double   */ 1,
    /* float    */ 5,
    /* int32    */ 0,
    /* uint32   */ 0,
    /* sint32   */ 0,
    /* fixed32  */ 5,
    /* sfixed32 */ 5,
    /* int64    */ 0,
    /* uint64   */ 0,
    /* sint64   */ 0,
    /* fixed64  */ 1,
    /* sfixed64 */ 1,
    /* bool     */ 0
            ]);

        }, { "37": 37 }], 37: [function (require, module, exports) {
            "use strict";

            /**
             * Various utility functions.
             * @namespace
             */
            var util = module.exports = require(39);

            var roots = require(30);

            var Type, // cyclic
                Enum;

            util.codegen = require(3);
            util.fetch = require(5);
            util.path = require(8);

            /**
             * Node's fs module if available.
             * @type {Object.<string,*>}
             */
            util.fs = util.inquire("fs");

            /**
             * Converts an object's values to an array.
             * @param {Object.<string,*>} object Object to convert
             * @returns {Array.<*>} Converted array
             */
            util.toArray = function toArray(object) {
                if (object) {
                    var keys = Object.keys(object),
                        array = new Array(keys.length),
                        index = 0;
                    while (index < keys.length)
                        array[index] = object[keys[index++]];
                    return array;
                }
                return [];
            };

            /**
             * Converts an array of keys immediately followed by their respective value to an object, omitting undefined values.
             * @param {Array.<*>} array Array to convert
             * @returns {Object.<string,*>} Converted object
             */
            util.toObject = function toObject(array) {
                var object = {},
                    index = 0;
                while (index < array.length) {
                    var key = array[index++],
                        val = array[index++];
                    if (val !== undefined)
                        object[key] = val;
                }
                return object;
            };

            var safePropBackslashRe = /\\/g,
                safePropQuoteRe = /"/g;

            /**
             * Tests whether the specified name is a reserved word in JS.
             * @param {string} name Name to test
             * @returns {boolean} `true` if reserved, otherwise `false`
             */
            util.isReserved = function isReserved(name) {
                return /^(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)$/.test(name);
            };

            /**
             * Returns a safe property accessor for the specified property name.
             * @param {string} prop Property name
             * @returns {string} Safe accessor
             */
            util.safeProp = function safeProp(prop) {
                if (!/^[$\w_]+$/.test(prop) || util.isReserved(prop))
                    return "[\"" + prop.replace(safePropBackslashRe, "\\\\").replace(safePropQuoteRe, "\\\"") + "\"]";
                return "." + prop;
            };

            /**
             * Converts the first character of a string to upper case.
             * @param {string} str String to convert
             * @returns {string} Converted string
             */
            util.ucFirst = function ucFirst(str) {
                return str.charAt(0).toUpperCase() + str.substring(1);
            };

            var camelCaseRe = /_([a-z])/g;

            /**
             * Converts a string to camel case.
             * @param {string} str String to convert
             * @returns {string} Converted string
             */
            util.camelCase = function camelCase(str) {
                return str.substring(0, 1)
                    + str.substring(1)
                        .replace(camelCaseRe, function ($0, $1) { return $1.toUpperCase(); });
            };

            /**
             * Compares reflected fields by id.
             * @param {Field} a First field
             * @param {Field} b Second field
             * @returns {number} Comparison value
             */
            util.compareFieldsById = function compareFieldsById(a, b) {
                return a.id - b.id;
            };

            /**
             * Decorator helper for types (TypeScript).
             * @param {Constructor<T>} ctor Constructor function
             * @param {string} [typeName] Type name, defaults to the constructor's name
             * @returns {Type} Reflected type
             * @template T extends Message<T>
             * @property {Root} root Decorators root
             */
            util.decorateType = function decorateType(ctor, typeName) {

                /* istanbul ignore if */
                if (ctor.$type) {
                    if (typeName && ctor.$type.name !== typeName) {
                        util.decorateRoot.remove(ctor.$type);
                        ctor.$type.name = typeName;
                        util.decorateRoot.add(ctor.$type);
                    }
                    return ctor.$type;
                }

                /* istanbul ignore next */
                if (!Type)
                    Type = require(35);

                var type = new Type(typeName || ctor.name);
                util.decorateRoot.add(type);
                type.ctor = ctor; // sets up .encode, .decode etc.
                Object.defineProperty(ctor, "$type", { value: type, enumerable: false });
                Object.defineProperty(ctor.prototype, "$type", { value: type, enumerable: false });
                return type;
            };

            var decorateEnumIndex = 0;

            /**
             * Decorator helper for enums (TypeScript).
             * @param {Object} object Enum object
             * @returns {Enum} Reflected enum
             */
            util.decorateEnum = function decorateEnum(object) {

                /* istanbul ignore if */
                if (object.$type)
                    return object.$type;

                /* istanbul ignore next */
                if (!Enum)
                    Enum = require(15);

                var enm = new Enum("Enum" + decorateEnumIndex++, object);
                util.decorateRoot.add(enm);
                Object.defineProperty(object, "$type", { value: enm, enumerable: false });
                return enm;
            };

            /**
             * Decorator root (TypeScript).
             * @name util.decorateRoot
             * @type {Root}
             * @readonly
             */
            Object.defineProperty(util, "decorateRoot", {
                get: function () {
                    return roots["decorated"] || (roots["decorated"] = new (require(29))());
                }
            });

        }, { "15": 15, "29": 29, "3": 3, "30": 30, "35": 35, "39": 39, "5": 5, "8": 8 }], 38: [function (require, module, exports) {
            "use strict";
            module.exports = LongBits;

            var util = require(39);

            /**
             * Constructs new long bits.
             * @classdesc Helper class for working with the low and high bits of a 64 bit value.
             * @memberof util
             * @constructor
             * @param {number} lo Low 32 bits, unsigned
             * @param {number} hi High 32 bits, unsigned
             */
            function LongBits(lo, hi) {

                // note that the casts below are theoretically unnecessary as of today, but older statically
                // generated converter code might still call the ctor with signed 32bits. kept for compat.

                /**
                 * Low bits.
                 * @type {number}
                 */
                this.lo = lo >>> 0;

                /**
                 * High bits.
                 * @type {number}
                 */
                this.hi = hi >>> 0;
            }

            /**
             * Zero bits.
             * @memberof util.LongBits
             * @type {util.LongBits}
             */
            var zero = LongBits.zero = new LongBits(0, 0);

            zero.toNumber = function () { return 0; };
            zero.zzEncode = zero.zzDecode = function () { return this; };
            zero.length = function () { return 1; };

            /**
             * Zero hash.
             * @memberof util.LongBits
             * @type {string}
             */
            var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";

            /**
             * Constructs new long bits from the specified number.
             * @param {number} value Value
             * @returns {util.LongBits} Instance
             */
            LongBits.fromNumber = function fromNumber(value) {
                if (value === 0)
                    return zero;
                var sign = value < 0;
                if (sign)
                    value = -value;
                var lo = value >>> 0,
                    hi = (value - lo) / 4294967296 >>> 0;
                if (sign) {
                    hi = ~hi >>> 0;
                    lo = ~lo >>> 0;
                    if (++lo > 4294967295) {
                        lo = 0;
                        if (++hi > 4294967295)
                            hi = 0;
                    }
                }
                return new LongBits(lo, hi);
            };

            /**
             * Constructs new long bits from a number, long or string.
             * @param {Long|number|string} value Value
             * @returns {util.LongBits} Instance
             */
            LongBits.from = function from(value) {
                if (typeof value === "number")
                    return LongBits.fromNumber(value);
                if (util.isString(value)) {
                    /* istanbul ignore else */
                    if (util.Long)
                        value = util.Long.fromString(value);
                    else
                        return LongBits.fromNumber(parseInt(value, 10));
                }
                return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
            };

            /**
             * Converts this long bits to a possibly unsafe JavaScript number.
             * @param {boolean} [unsigned=false] Whether unsigned or not
             * @returns {number} Possibly unsafe number
             */
            LongBits.prototype.toNumber = function toNumber(unsigned) {
                if (!unsigned && this.hi >>> 31) {
                    var lo = ~this.lo + 1 >>> 0,
                        hi = ~this.hi >>> 0;
                    if (!lo)
                        hi = hi + 1 >>> 0;
                    return -(lo + hi * 4294967296);
                }
                return this.lo + this.hi * 4294967296;
            };

            /**
             * Converts this long bits to a long.
             * @param {boolean} [unsigned=false] Whether unsigned or not
             * @returns {Long} Long
             */
            LongBits.prototype.toLong = function toLong(unsigned) {
                return util.Long
                    ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))
                    /* istanbul ignore next */
                    : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
            };

            var charCodeAt = String.prototype.charCodeAt;

            /**
             * Constructs new long bits from the specified 8 characters long hash.
             * @param {string} hash Hash
             * @returns {util.LongBits} Bits
             */
            LongBits.fromHash = function fromHash(hash) {
                if (hash === zeroHash)
                    return zero;
                return new LongBits(
                    (charCodeAt.call(hash, 0)
                        | charCodeAt.call(hash, 1) << 8
                        | charCodeAt.call(hash, 2) << 16
                        | charCodeAt.call(hash, 3) << 24) >>> 0
                    ,
                    (charCodeAt.call(hash, 4)
                        | charCodeAt.call(hash, 5) << 8
                        | charCodeAt.call(hash, 6) << 16
                        | charCodeAt.call(hash, 7) << 24) >>> 0
                );
            };

            /**
             * Converts this long bits to a 8 characters long hash.
             * @returns {string} Hash
             */
            LongBits.prototype.toHash = function toHash() {
                return String.fromCharCode(
                    this.lo & 255,
                    this.lo >>> 8 & 255,
                    this.lo >>> 16 & 255,
                    this.lo >>> 24,
                    this.hi & 255,
                    this.hi >>> 8 & 255,
                    this.hi >>> 16 & 255,
                    this.hi >>> 24
                );
            };

            /**
             * Zig-zag encodes this long bits.
             * @returns {util.LongBits} `this`
             */
            LongBits.prototype.zzEncode = function zzEncode() {
                var mask = this.hi >> 31;
                this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
                this.lo = (this.lo << 1 ^ mask) >>> 0;
                return this;
            };

            /**
             * Zig-zag decodes this long bits.
             * @returns {util.LongBits} `this`
             */
            LongBits.prototype.zzDecode = function zzDecode() {
                var mask = -(this.lo & 1);
                this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
                this.hi = (this.hi >>> 1 ^ mask) >>> 0;
                return this;
            };

            /**
             * Calculates the length of this longbits when encoded as a varint.
             * @returns {number} Length
             */
            LongBits.prototype.length = function length() {
                var part0 = this.lo,
                    part1 = (this.lo >>> 28 | this.hi << 4) >>> 0,
                    part2 = this.hi >>> 24;
                return part2 === 0
                    ? part1 === 0
                        ? part0 < 16384
                            ? part0 < 128 ? 1 : 2
                            : part0 < 2097152 ? 3 : 4
                        : part1 < 16384
                            ? part1 < 128 ? 5 : 6
                            : part1 < 2097152 ? 7 : 8
                    : part2 < 128 ? 9 : 10;
            };

        }, { "39": 39 }], 39: [function (require, module, exports) {
            "use strict";
            var util = exports;

            // used to return a Promise where callback is omitted
            util.asPromise = require(1);

            // converts to / from base64 encoded strings
            util.base64 = require(2);

            // base class of rpc.Service
            util.EventEmitter = require(4);

            // float handling accross browsers
            util.float = require(6);

            // requires modules optionally and hides the call from bundlers
            util.inquire = require(7);

            // converts to / from utf8 encoded strings
            util.utf8 = require(10);

            // provides a node-like buffer pool in the browser
            util.pool = require(9);

            // utility to work with the low and high bits of a 64 bit value
            util.LongBits = require(38);

            /**
             * An immuable empty array.
             * @memberof util
             * @type {Array.<*>}
             * @const
             */
            util.emptyArray = Object.freeze ? Object.freeze([]) : /* istanbul ignore next */[]; // used on prototypes

            /**
             * An immutable empty object.
             * @type {Object}
             * @const
             */
            util.emptyObject = Object.freeze ? Object.freeze({}) : /* istanbul ignore next */ {}; // used on prototypes

            /**
             * Whether running within node or not.
             * @memberof util
             * @type {boolean}
             * @const
             */
            util.isNode = Boolean(global.process && global.process.versions && global.process.versions.node);

            /**
             * Tests if the specified value is an integer.
             * @function
             * @param {*} value Value to test
             * @returns {boolean} `true` if the value is an integer
             */
            util.isInteger = Number.isInteger || /* istanbul ignore next */ function isInteger(value) {
                return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
            };

            /**
             * Tests if the specified value is a string.
             * @param {*} value Value to test
             * @returns {boolean} `true` if the value is a string
             */
            util.isString = function isString(value) {
                return typeof value === "string" || value instanceof String;
            };

            /**
             * Tests if the specified value is a non-null object.
             * @param {*} value Value to test
             * @returns {boolean} `true` if the value is a non-null object
             */
            util.isObject = function isObject(value) {
                return value && typeof value === "object";
            };

            /**
             * Checks if a property on a message is considered to be present.
             * This is an alias of {@link util.isSet}.
             * @function
             * @param {Object} obj Plain object or message instance
             * @param {string} prop Property name
             * @returns {boolean} `true` if considered to be present, otherwise `false`
             */
            util.isset =

                /**
                 * Checks if a property on a message is considered to be present.
                 * @param {Object} obj Plain object or message instance
                 * @param {string} prop Property name
                 * @returns {boolean} `true` if considered to be present, otherwise `false`
                 */
                util.isSet = function isSet(obj, prop) {
                    var value = obj[prop];
                    if (value != null && obj.hasOwnProperty(prop)) // eslint-disable-line eqeqeq, no-prototype-builtins
                        return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
                    return false;
                };

            /**
             * Any compatible Buffer instance.
             * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.
             * @interface Buffer
             * @extends Uint8Array
             */

            /**
             * Node's Buffer class if available.
             * @type {Constructor<Buffer>}
             */
            util.Buffer = (function () {
                try {
                    var Buffer = util.inquire("buffer").Buffer;
                    // refuse to use non-node buffers if not explicitly assigned (perf reasons):
                    return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */ null;
                } catch (e) {
                    /* istanbul ignore next */
                    return null;
                }
            })();

            // Internal alias of or polyfull for Buffer.from.
            util._Buffer_from = null;

            // Internal alias of or polyfill for Buffer.allocUnsafe.
            util._Buffer_allocUnsafe = null;

            /**
             * Creates a new buffer of whatever type supported by the environment.
             * @param {number|number[]} [sizeOrArray=0] Buffer size or number array
             * @returns {Uint8Array|Buffer} Buffer
             */
            util.newBuffer = function newBuffer(sizeOrArray) {
                /* istanbul ignore next */
                return typeof sizeOrArray === "number"
                    ? util.Buffer
                        ? util._Buffer_allocUnsafe(sizeOrArray)
                        : new util.Array(sizeOrArray)
                    : util.Buffer
                        ? util._Buffer_from(sizeOrArray)
                        : typeof Uint8Array === "undefined"
                            ? sizeOrArray
                            : new Uint8Array(sizeOrArray);
            };

            /**
             * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.
             * @type {Constructor<Uint8Array>}
             */
            util.Array = typeof Uint8Array !== "undefined" ? Uint8Array /* istanbul ignore next */ : Array;

            /**
             * Any compatible Long instance.
             * This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.
             * @interface Long
             * @property {number} low Low bits
             * @property {number} high High bits
             * @property {boolean} unsigned Whether unsigned or not
             */

            /**
             * Long.js's Long class if available.
             * @type {Constructor<Long>}
             */
            util.Long = /* istanbul ignore next */ global.dcodeIO && /* istanbul ignore next */ global.dcodeIO.Long || util.inquire("long");

            /**
             * Regular expression used to verify 2 bit (`bool`) map keys.
             * @type {RegExp}
             * @const
             */
            util.key2Re = /^true|false|0|1$/;

            /**
             * Regular expression used to verify 32 bit (`int32` etc.) map keys.
             * @type {RegExp}
             * @const
             */
            util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;

            /**
             * Regular expression used to verify 64 bit (`int64` etc.) map keys.
             * @type {RegExp}
             * @const
             */
            util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;

            /**
             * Converts a number or long to an 8 characters long hash string.
             * @param {Long|number} value Value to convert
             * @returns {string} Hash
             */
            util.longToHash = function longToHash(value) {
                return value
                    ? util.LongBits.from(value).toHash()
                    : util.LongBits.zeroHash;
            };

            /**
             * Converts an 8 characters long hash string to a long or number.
             * @param {string} hash Hash
             * @param {boolean} [unsigned=false] Whether unsigned or not
             * @returns {Long|number} Original value
             */
            util.longFromHash = function longFromHash(hash, unsigned) {
                var bits = util.LongBits.fromHash(hash);
                if (util.Long)
                    return util.Long.fromBits(bits.lo, bits.hi, unsigned);
                return bits.toNumber(Boolean(unsigned));
            };

            /**
             * Merges the properties of the source object into the destination object.
             * @memberof util
             * @param {Object.<string,*>} dst Destination object
             * @param {Object.<string,*>} src Source object
             * @param {boolean} [ifNotSet=false] Merges only if the key is not already set
             * @returns {Object.<string,*>} Destination object
             */
            function merge(dst, src, ifNotSet) { // used by converters
                for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
                    if (dst[keys[i]] === undefined || !ifNotSet)
                        dst[keys[i]] = src[keys[i]];
                return dst;
            }

            util.merge = merge;

            /**
             * Converts the first character of a string to lower case.
             * @param {string} str String to convert
             * @returns {string} Converted string
             */
            util.lcFirst = function lcFirst(str) {
                return str.charAt(0).toLowerCase() + str.substring(1);
            };

            /**
             * Creates a custom error constructor.
             * @memberof util
             * @param {string} name Error name
             * @returns {Constructor<Error>} Custom error constructor
             */
            function newError(name) {

                function CustomError(message, properties) {

                    if (!(this instanceof CustomError))
                        return new CustomError(message, properties);

                    // Error.call(this, message);
                    // ^ just returns a new error instance because the ctor can be called as a function

                    Object.defineProperty(this, "message", { get: function () { return message; } });

                    /* istanbul ignore next */
                    if (Error.captureStackTrace) // node
                        Error.captureStackTrace(this, CustomError);
                    else
                        Object.defineProperty(this, "stack", { value: (new Error()).stack || "" });

                    if (properties)
                        merge(this, properties);
                }

                (CustomError.prototype = Object.create(Error.prototype)).constructor = CustomError;

                Object.defineProperty(CustomError.prototype, "name", { get: function () { return name; } });

                CustomError.prototype.toString = function toString() {
                    return this.name + ": " + this.message;
                };

                return CustomError;
            }

            util.newError = newError;

            /**
             * Constructs a new protocol error.
             * @classdesc Error subclass indicating a protocol specifc error.
             * @memberof util
             * @extends Error
             * @template T extends Message<T>
             * @constructor
             * @param {string} message Error message
             * @param {Object.<string,*>} [properties] Additional properties
             * @example
             * try {
             *     MyMessage.decode(someBuffer); // throws if required fields are missing
             * } catch (e) {
             *     if (e instanceof ProtocolError && e.instance)
             *         console.log("decoded so far: " + JSON.stringify(e.instance));
             * }
             */
            util.ProtocolError = newError("ProtocolError");

            /**
             * So far decoded message instance.
             * @name util.ProtocolError#instance
             * @type {Message<T>}
             */

            /**
             * A OneOf getter as returned by {@link util.oneOfGetter}.
             * @typedef OneOfGetter
             * @type {function}
             * @returns {string|undefined} Set field name, if any
             */

            /**
             * Builds a getter for a oneof's present field name.
             * @param {string[]} fieldNames Field names
             * @returns {OneOfGetter} Unbound getter
             */
            util.oneOfGetter = function getOneOf(fieldNames) {
                var fieldMap = {};
                for (var i = 0; i < fieldNames.length; ++i)
                    fieldMap[fieldNames[i]] = 1;

                /**
                 * @returns {string|undefined} Set field name, if any
                 * @this Object
                 * @ignore
                 */
                return function () { // eslint-disable-line consistent-return
                    for (var keys = Object.keys(this), i = keys.length - 1; i > -1; --i)
                        if (fieldMap[keys[i]] === 1 && this[keys[i]] !== undefined && this[keys[i]] !== null)
                            return keys[i];
                };
            };

            /**
             * A OneOf setter as returned by {@link util.oneOfSetter}.
             * @typedef OneOfSetter
             * @type {function}
             * @param {string|undefined} value Field name
             * @returns {undefined}
             */

            /**
             * Builds a setter for a oneof's present field name.
             * @param {string[]} fieldNames Field names
             * @returns {OneOfSetter} Unbound setter
             */
            util.oneOfSetter = function setOneOf(fieldNames) {

                /**
                 * @param {string} name Field name
                 * @returns {undefined}
                 * @this Object
                 * @ignore
                 */
                return function (name) {
                    for (var i = 0; i < fieldNames.length; ++i)
                        if (fieldNames[i] !== name)
                            delete this[fieldNames[i]];
                };
            };

            /**
             * Default conversion options used for {@link Message#toJSON} implementations.
             *
             * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:
             *
             * - Longs become strings
             * - Enums become string keys
             * - Bytes become base64 encoded strings
             * - (Sub-)Messages become plain objects
             * - Maps become plain objects with all string keys
             * - Repeated fields become arrays
             * - NaN and Infinity for float and double fields become strings
             *
             * @type {IConversionOptions}
             * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json
             */
            util.toJSONOptions = {
                longs: String,
                enums: String,
                bytes: String,
                json: true
            };

            util._configure = function () {
                var Buffer = util.Buffer;
                /* istanbul ignore if */
                if (!Buffer) {
                    util._Buffer_from = util._Buffer_allocUnsafe = null;
                    return;
                }
                // because node 4.x buffers are incompatible & immutable
                // see: https://github.com/dcodeIO/protobuf.js/pull/665
                util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||
                    /* istanbul ignore next */
                    function Buffer_from(value, encoding) {
                        return new Buffer(value, encoding);
                    };
                util._Buffer_allocUnsafe = Buffer.allocUnsafe ||
                    /* istanbul ignore next */
                    function Buffer_allocUnsafe(size) {
                        return new Buffer(size);
                    };
            };

        }, { "1": 1, "10": 10, "2": 2, "38": 38, "4": 4, "6": 6, "7": 7, "9": 9 }], 40: [function (require, module, exports) {
            "use strict";
            module.exports = verifier;

            var Enum = require(15),
                util = require(37);

            function invalid(field, expected) {
                return field.name + ": " + expected + (field.repeated && expected !== "array" ? "[]" : field.map && expected !== "object" ? "{k:" + field.keyType + "}" : "") + " expected";
            }

            /**
             * Generates a partial value verifier.
             * @param {Codegen} gen Codegen instance
             * @param {Field} field Reflected field
             * @param {number} fieldIndex Field index
             * @param {string} ref Variable reference
             * @returns {Codegen} Codegen instance
             * @ignore
             */
            function genVerifyValue(gen, field, fieldIndex, ref) {
                /* eslint-disable no-unexpected-multiline */
                if (field.resolvedType) {
                    if (field.resolvedType instanceof Enum) {
                        gen
                            ("switch(%s){", ref)
                        ("default:")
                        ("return%j", invalid(field, "enum value"));
                        for (var keys = Object.keys(field.resolvedType.values), j = 0; j < keys.length; ++j) gen
                            ("case %i:", field.resolvedType.values[keys[j]]);
                        gen
                            ("break")
                            ("}");
                    } else {
                        gen
                            ("{")
                            ("var e=types[%i].verify(%s);", fieldIndex, ref)
                            ("if(e)")
                            ("return%j+e", field.name + ".")
                            ("}");
                    }
                } else {
                    switch (field.type) {
                        case "int32":
                        case "uint32":
                        case "sint32":
                        case "fixed32":
                        case "sfixed32": gen
                            ("if(!util.isInteger(%s))", ref)
                            ("return%j", invalid(field, "integer"));
                            break;
                        case "int64":
                        case "uint64":
                        case "sint64":
                        case "fixed64":
                        case "sfixed64": gen
                            ("if(!util.isInteger(%s)&&!(%s&&util.isInteger(%s.low)&&util.isInteger(%s.high)))", ref, ref, ref, ref)
                            ("return%j", invalid(field, "integer|Long"));
                            break;
                        case "float":
                        case "double": gen
                            ("if(typeof %s!==\"number\")", ref)
                            ("return%j", invalid(field, "number"));
                            break;
                        case "bool": gen
                            ("if(typeof %s!==\"boolean\")", ref)
                            ("return%j", invalid(field, "boolean"));
                            break;
                        case "string": gen
                            ("if(!util.isString(%s))", ref)
                            ("return%j", invalid(field, "string"));
                            break;
                        case "bytes": gen
                            ("if(!(%s&&typeof %s.length===\"number\"||util.isString(%s)))", ref, ref, ref)
                            ("return%j", invalid(field, "buffer"));
                            break;
                    }
                }
                return gen;
                /* eslint-enable no-unexpected-multiline */
            }

            /**
             * Generates a partial key verifier.
             * @param {Codegen} gen Codegen instance
             * @param {Field} field Reflected field
             * @param {string} ref Variable reference
             * @returns {Codegen} Codegen instance
             * @ignore
             */
            function genVerifyKey(gen, field, ref) {
                /* eslint-disable no-unexpected-multiline */
                switch (field.keyType) {
                    case "int32":
                    case "uint32":
                    case "sint32":
                    case "fixed32":
                    case "sfixed32": gen
                        ("if(!util.key32Re.test(%s))", ref)
                        ("return%j", invalid(field, "integer key"));
                        break;
                    case "int64":
                    case "uint64":
                    case "sint64":
                    case "fixed64":
                    case "sfixed64": gen
                        ("if(!util.key64Re.test(%s))", ref) // see comment above: x is ok, d is not
                        ("return%j", invalid(field, "integer|Long key"));
                        break;
                    case "bool": gen
                        ("if(!util.key2Re.test(%s))", ref)
                        ("return%j", invalid(field, "boolean key"));
                        break;
                }
                return gen;
                /* eslint-enable no-unexpected-multiline */
            }

            /**
             * Generates a verifier specific to the specified message type.
             * @param {Type} mtype Message type
             * @returns {Codegen} Codegen instance
             */
            function verifier(mtype) {
                /* eslint-disable no-unexpected-multiline */

                var gen = util.codegen(["m"], mtype.name + "$verify")
                    ("if(typeof m!==\"object\"||m===null)")
                    ("return%j", "object expected");
                var oneofs = mtype.oneofsArray,
                    seenFirstField = {};
                if (oneofs.length) gen
                    ("var p={}");

                for (var i = 0; i < /* initializes */ mtype.fieldsArray.length; ++i) {
                    var field = mtype._fieldsArray[i].resolve(),
                        ref = "m" + util.safeProp(field.name);

                    if (field.optional) gen
                        ("if(%s!=null&&m.hasOwnProperty(%j)){", ref, field.name); // !== undefined && !== null

                    // map fields
                    if (field.map) {
                        gen
                            ("if(!util.isObject(%s))", ref)
                        ("return%j", invalid(field, "object"))
                        ("var k=Object.keys(%s)", ref)
                        ("for(var i=0;i<k.length;++i){");
                        genVerifyKey(gen, field, "k[i]");
                        genVerifyValue(gen, field, i, ref + "[k[i]]")
                            ("}");

                        // repeated fields
                    } else if (field.repeated) {
                        gen
                            ("if(!Array.isArray(%s))", ref)
                        ("return%j", invalid(field, "array"))
                        ("for(var i=0;i<%s.length;++i){", ref);
                        genVerifyValue(gen, field, i, ref + "[i]")
                            ("}");

                        // required or present fields
                    } else {
                        if (field.partOf) {
                            var oneofProp = util.safeProp(field.partOf.name);
                            if (seenFirstField[field.partOf.name] === 1) gen
                                ("if(p%s===1)", oneofProp)
                                ("return%j", field.partOf.name + ": multiple values");
                            seenFirstField[field.partOf.name] = 1;
                            gen
                                ("p%s=1", oneofProp);
                        }
                        genVerifyValue(gen, field, i, ref);
                    }
                    if (field.optional) gen
                        ("}");
                }
                return gen
                    ("return null");
                /* eslint-enable no-unexpected-multiline */
            }
        }, { "15": 15, "37": 37 }], 41: [function (require, module, exports) {
            "use strict";

            /**
             * Wrappers for common types.
             * @type {Object.<string,IWrapper>}
             * @const
             */
            var wrappers = exports;

            var Message = require(21);

            /**
             * From object converter part of an {@link IWrapper}.
             * @typedef WrapperFromObjectConverter
             * @type {function}
             * @param {Object.<string,*>} object Plain object
             * @returns {Message<{}>} Message instance
             * @this Type
             */

            /**
             * To object converter part of an {@link IWrapper}.
             * @typedef WrapperToObjectConverter
             * @type {function}
             * @param {Message<{}>} message Message instance
             * @param {IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             * @this Type
             */

            /**
             * Common type wrapper part of {@link wrappers}.
             * @interface IWrapper
             * @property {WrapperFromObjectConverter} [fromObject] From object converter
             * @property {WrapperToObjectConverter} [toObject] To object converter
             */

            // Custom wrapper for Any
            wrappers[".google.protobuf.Any"] = {

                fromObject: function (object) {

                    // unwrap value type if mapped
                    if (object && object["@type"]) {
                        var type = this.lookup(object["@type"]);
                        /* istanbul ignore else */
                        if (type) {
                            // type_url does not accept leading "."
                            var type_url = object["@type"].charAt(0) === "." ?
                                object["@type"].substr(1) : object["@type"];
                            // type_url prefix is optional, but path seperator is required
                            return this.create({
                                type_url: "/" + type_url,
                                value: type.encode(type.fromObject(object)).finish()
                            });
                        }
                    }

                    return this.fromObject(object);
                },

                toObject: function (message, options) {

                    // decode value if requested and unmapped
                    if (options && options.json && message.type_url && message.value) {
                        // Only use fully qualified type name after the last '/'
                        var name = message.type_url.substring(message.type_url.lastIndexOf("/") + 1);
                        var type = this.lookup(name);
                        /* istanbul ignore else */
                        if (type)
                            message = type.decode(message.value);
                    }

                    // wrap value if unmapped
                    if (!(message instanceof this.ctor) && message instanceof Message) {
                        var object = message.$type.toObject(message, options);
                        object["@type"] = message.$type.fullName;
                        return object;
                    }

                    return this.toObject(message, options);
                }
            };

        }, { "21": 21 }], 42: [function (require, module, exports) {
            "use strict";
            module.exports = Writer;

            var util = require(39);

            var BufferWriter; // cyclic

            var LongBits = util.LongBits,
                base64 = util.base64,
                utf8 = util.utf8;

            /**
             * Constructs a new writer operation instance.
             * @classdesc Scheduled writer operation.
             * @constructor
             * @param {function(*, Uint8Array, number)} fn Function to call
             * @param {number} len Value byte length
             * @param {*} val Value to write
             * @ignore
             */
            function Op(fn, len, val) {

                /**
                 * Function to call.
                 * @type {function(Uint8Array, number, *)}
                 */
                this.fn = fn;

                /**
                 * Value byte length.
                 * @type {number}
                 */
                this.len = len;

                /**
                 * Next operation.
                 * @type {Writer.Op|undefined}
                 */
                this.next = undefined;

                /**
                 * Value to write.
                 * @type {*}
                 */
                this.val = val; // type varies
            }

            /* istanbul ignore next */
            function noop() { } // eslint-disable-line no-empty-function

            /**
             * Constructs a new writer state instance.
             * @classdesc Copied writer state.
             * @memberof Writer
             * @constructor
             * @param {Writer} writer Writer to copy state from
             * @ignore
             */
            function State(writer) {

                /**
                 * Current head.
                 * @type {Writer.Op}
                 */
                this.head = writer.head;

                /**
                 * Current tail.
                 * @type {Writer.Op}
                 */
                this.tail = writer.tail;

                /**
                 * Current buffer length.
                 * @type {number}
                 */
                this.len = writer.len;

                /**
                 * Next state.
                 * @type {State|null}
                 */
                this.next = writer.states;
            }

            /**
             * Constructs a new writer instance.
             * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.
             * @constructor
             */
            function Writer() {

                /**
                 * Current length.
                 * @type {number}
                 */
                this.len = 0;

                /**
                 * Operations head.
                 * @type {Object}
                 */
                this.head = new Op(noop, 0, 0);

                /**
                 * Operations tail
                 * @type {Object}
                 */
                this.tail = this.head;

                /**
                 * Linked forked states.
                 * @type {Object|null}
                 */
                this.states = null;

                // When a value is written, the writer calculates its byte length and puts it into a linked
                // list of operations to perform when finish() is called. This both allows us to allocate
                // buffers of the exact required size and reduces the amount of work we have to do compared
                // to first calculating over objects and then encoding over objects. In our case, the encoding
                // part is just a linked list walk calling operations with already prepared values.
            }

            /**
             * Creates a new writer.
             * @function
             * @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}
             */
            Writer.create = util.Buffer
                ? function create_buffer_setup() {
                    return (Writer.create = function create_buffer() {
                        return new BufferWriter();
                    })();
                }
                /* istanbul ignore next */
                : function create_array() {
                    return new Writer();
                };

            /**
             * Allocates a buffer of the specified size.
             * @param {number} size Buffer size
             * @returns {Uint8Array} Buffer
             */
            Writer.alloc = function alloc(size) {
                return new util.Array(size);
            };

            // Use Uint8Array buffer pool in the browser, just like node does with buffers
            /* istanbul ignore else */
            if (util.Array !== Array)
                Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);

            /**
             * Pushes a new operation to the queue.
             * @param {function(Uint8Array, number, *)} fn Function to call
             * @param {number} len Value byte length
             * @param {number} val Value to write
             * @returns {Writer} `this`
             * @private
             */
            Writer.prototype._push = function push(fn, len, val) {
                this.tail = this.tail.next = new Op(fn, len, val);
                this.len += len;
                return this;
            };

            function writeByte(val, buf, pos) {
                buf[pos] = val & 255;
            }

            function writeVarint32(val, buf, pos) {
                while (val > 127) {
                    buf[pos++] = val & 127 | 128;
                    val >>>= 7;
                }
                buf[pos] = val;
            }

            /**
             * Constructs a new varint writer operation instance.
             * @classdesc Scheduled varint writer operation.
             * @extends Op
             * @constructor
             * @param {number} len Value byte length
             * @param {number} val Value to write
             * @ignore
             */
            function VarintOp(len, val) {
                this.len = len;
                this.next = undefined;
                this.val = val;
            }

            VarintOp.prototype = Object.create(Op.prototype);
            VarintOp.prototype.fn = writeVarint32;

            /**
             * Writes an unsigned 32 bit value as a varint.
             * @param {number} value Value to write
             * @returns {Writer} `this`
             */
            Writer.prototype.uint32 = function write_uint32(value) {
                // here, the call to this.push has been inlined and a varint specific Op subclass is used.
                // uint32 is by far the most frequently used operation and benefits significantly from this.
                this.len += (this.tail = this.tail.next = new VarintOp(
                    (value = value >>> 0)
                        < 128 ? 1
                        : value < 16384 ? 2
                            : value < 2097152 ? 3
                                : value < 268435456 ? 4
                                    : 5,
                    value)).len;
                return this;
            };

            /**
             * Writes a signed 32 bit value as a varint.
             * @function
             * @param {number} value Value to write
             * @returns {Writer} `this`
             */
            Writer.prototype.int32 = function write_int32(value) {
                return value < 0
                    ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec
                    : this.uint32(value);
            };

            /**
             * Writes a 32 bit value as a varint, zig-zag encoded.
             * @param {number} value Value to write
             * @returns {Writer} `this`
             */
            Writer.prototype.sint32 = function write_sint32(value) {
                return this.uint32((value << 1 ^ value >> 31) >>> 0);
            };

            function writeVarint64(val, buf, pos) {
                while (val.hi) {
                    buf[pos++] = val.lo & 127 | 128;
                    val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
                    val.hi >>>= 7;
                }
                while (val.lo > 127) {
                    buf[pos++] = val.lo & 127 | 128;
                    val.lo = val.lo >>> 7;
                }
                buf[pos++] = val.lo;
            }

            /**
             * Writes an unsigned 64 bit value as a varint.
             * @param {Long|number|string} value Value to write
             * @returns {Writer} `this`
             * @throws {TypeError} If `value` is a string and no long library is present.
             */
            Writer.prototype.uint64 = function write_uint64(value) {
                var bits = LongBits.from(value);
                return this._push(writeVarint64, bits.length(), bits);
            };

            /**
             * Writes a signed 64 bit value as a varint.
             * @function
             * @param {Long|number|string} value Value to write
             * @returns {Writer} `this`
             * @throws {TypeError} If `value` is a string and no long library is present.
             */
            Writer.prototype.int64 = Writer.prototype.uint64;

            /**
             * Writes a signed 64 bit value as a varint, zig-zag encoded.
             * @param {Long|number|string} value Value to write
             * @returns {Writer} `this`
             * @throws {TypeError} If `value` is a string and no long library is present.
             */
            Writer.prototype.sint64 = function write_sint64(value) {
                var bits = LongBits.from(value).zzEncode();
                return this._push(writeVarint64, bits.length(), bits);
            };

            /**
             * Writes a boolish value as a varint.
             * @param {boolean} value Value to write
             * @returns {Writer} `this`
             */
            Writer.prototype.bool = function write_bool(value) {
                return this._push(writeByte, 1, value ? 1 : 0);
            };

            function writeFixed32(val, buf, pos) {
                buf[pos] = val & 255;
                buf[pos + 1] = val >>> 8 & 255;
                buf[pos + 2] = val >>> 16 & 255;
                buf[pos + 3] = val >>> 24;
            }

            /**
             * Writes an unsigned 32 bit value as fixed 32 bits.
             * @param {number} value Value to write
             * @returns {Writer} `this`
             */
            Writer.prototype.fixed32 = function write_fixed32(value) {
                return this._push(writeFixed32, 4, value >>> 0);
            };

            /**
             * Writes a signed 32 bit value as fixed 32 bits.
             * @function
             * @param {number} value Value to write
             * @returns {Writer} `this`
             */
            Writer.prototype.sfixed32 = Writer.prototype.fixed32;

            /**
             * Writes an unsigned 64 bit value as fixed 64 bits.
             * @param {Long|number|string} value Value to write
             * @returns {Writer} `this`
             * @throws {TypeError} If `value` is a string and no long library is present.
             */
            Writer.prototype.fixed64 = function write_fixed64(value) {
                var bits = LongBits.from(value);
                return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
            };

            /**
             * Writes a signed 64 bit value as fixed 64 bits.
             * @function
             * @param {Long|number|string} value Value to write
             * @returns {Writer} `this`
             * @throws {TypeError} If `value` is a string and no long library is present.
             */
            Writer.prototype.sfixed64 = Writer.prototype.fixed64;

            /**
             * Writes a float (32 bit).
             * @function
             * @param {number} value Value to write
             * @returns {Writer} `this`
             */
            Writer.prototype.float = function write_float(value) {
                return this._push(util.float.writeFloatLE, 4, value);
            };

            /**
             * Writes a double (64 bit float).
             * @function
             * @param {number} value Value to write
             * @returns {Writer} `this`
             */
            Writer.prototype.double = function write_double(value) {
                return this._push(util.float.writeDoubleLE, 8, value);
            };

            var writeBytes = util.Array.prototype.set
                ? function writeBytes_set(val, buf, pos) {
                    buf.set(val, pos); // also works for plain array values
                }
                /* istanbul ignore next */
                : function writeBytes_for(val, buf, pos) {
                    for (var i = 0; i < val.length; ++i)
                        buf[pos + i] = val[i];
                };

            /**
             * Writes a sequence of bytes.
             * @param {Uint8Array|string} value Buffer or base64 encoded string to write
             * @returns {Writer} `this`
             */
            Writer.prototype.bytes = function write_bytes(value) {
                var len = value.length >>> 0;
                if (!len)
                    return this._push(writeByte, 1, 0);
                if (util.isString(value)) {
                    var buf = Writer.alloc(len = base64.length(value));
                    base64.decode(value, buf, 0);
                    value = buf;
                }
                return this.uint32(len)._push(writeBytes, len, value);
            };

            /**
             * Writes a string.
             * @param {string} value Value to write
             * @returns {Writer} `this`
             */
            Writer.prototype.string = function write_string(value) {
                var len = utf8.length(value);
                return len
                    ? this.uint32(len)._push(utf8.write, len, value)
                    : this._push(writeByte, 1, 0);
            };

            /**
             * Forks this writer's state by pushing it to a stack.
             * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
             * @returns {Writer} `this`
             */
            Writer.prototype.fork = function fork() {
                this.states = new State(this);
                this.head = this.tail = new Op(noop, 0, 0);
                this.len = 0;
                return this;
            };

            /**
             * Resets this instance to the last state.
             * @returns {Writer} `this`
             */
            Writer.prototype.reset = function reset() {
                if (this.states) {
                    this.head = this.states.head;
                    this.tail = this.states.tail;
                    this.len = this.states.len;
                    this.states = this.states.next;
                } else {
                    this.head = this.tail = new Op(noop, 0, 0);
                    this.len = 0;
                }
                return this;
            };

            /**
             * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
             * @returns {Writer} `this`
             */
            Writer.prototype.ldelim = function ldelim() {
                var head = this.head,
                    tail = this.tail,
                    len = this.len;
                this.reset().uint32(len);
                if (len) {
                    this.tail.next = head.next; // skip noop
                    this.tail = tail;
                    this.len += len;
                }
                return this;
            };

            /**
             * Finishes the write operation.
             * @returns {Uint8Array} Finished buffer
             */
            Writer.prototype.finish = function finish() {
                var head = this.head.next, // skip noop
                    buf = this.constructor.alloc(this.len),
                    pos = 0;
                while (head) {
                    head.fn(head.val, buf, pos);
                    pos += head.len;
                    head = head.next;
                }
                // this.head = this.tail = null;
                return buf;
            };

            Writer._configure = function (BufferWriter_) {
                BufferWriter = BufferWriter_;
            };

        }, { "39": 39 }], 43: [function (require, module, exports) {
            "use strict";
            module.exports = BufferWriter;

            // extends Writer
            var Writer = require(42);
            (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;

            var util = require(39);

            var Buffer = util.Buffer;

            /**
             * Constructs a new buffer writer instance.
             * @classdesc Wire format writer using node buffers.
             * @extends Writer
             * @constructor
             */
            function BufferWriter() {
                Writer.call(this);
            }

            /**
             * Allocates a buffer of the specified size.
             * @param {number} size Buffer size
             * @returns {Buffer} Buffer
             */
            BufferWriter.alloc = function alloc_buffer(size) {
                return (BufferWriter.alloc = util._Buffer_allocUnsafe)(size);
            };

            var writeBytesBuffer = Buffer && Buffer.prototype instanceof Uint8Array && Buffer.prototype.set.name === "set"
                ? function writeBytesBuffer_set(val, buf, pos) {
                    buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)
                    // also works for plain array values
                }
                /* istanbul ignore next */
                : function writeBytesBuffer_copy(val, buf, pos) {
                    if (val.copy) // Buffer values
                        val.copy(buf, pos, 0, val.length);
                    else for (var i = 0; i < val.length;) // plain array values
                        buf[pos++] = val[i++];
                };

            /**
             * @override
             */
            BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
                if (util.isString(value))
                    value = util._Buffer_from(value, "base64");
                var len = value.length >>> 0;
                this.uint32(len);
                if (len)
                    this._push(writeBytesBuffer, len, value);
                return this;
            };

            function writeStringBuffer(val, buf, pos) {
                if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)
                    util.utf8.write(val, buf, pos);
                else
                    buf.utf8Write(val, pos);
            }

            /**
             * @override
             */
            BufferWriter.prototype.string = function write_string_buffer(value) {
                var len = Buffer.byteLength(value);
                this.uint32(len);
                if (len)
                    this._push(writeStringBuffer, len, value);
                return this;
            };


            /**
             * Finishes the write operation.
             * @name BufferWriter#finish
             * @function
             * @returns {Buffer} Finished buffer
             */

        }, { "39": 39, "42": 42 }]
    }, {}, [19])

})(typeof window === "object" && window || typeof self === "object" && self || this);